Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "k", "*", "Key", ")", "Params", "(", ")", "backend", ".", "Params", "{", "return", "backend", ".", "Params", "{", "Content", ":", "k", ".", "Content", ",", "Authority", ":", "k", ".", "Authority", ",", "FormatSpec", ":", "config", ".", "FormatSpec", "{", "k", ".", "Formatter", ",", "k", ".", "FormatData", "}", ",", "}", "\n", "}" ]

[ "Params", "returns", "the", "backend", ".", "Params", "that", "are", "encoded", "in", "this", "Key", "." ]

[ "func", "MakeValueItem", "(", "it", "*", "config", ".", "Config", ")", "ValueItem", "{", "return", "ValueItem", "{", "ConfigSet", ":", "string", "(", "it", ".", "ConfigSet", ")", ",", "Path", ":", "it", ".", "Path", ",", "ContentHash", ":", "it", ".", "ContentHash", ",", "Revision", ":", "it", ".", "Revision", ",", "ViewURL", ":", "it", ".", "Meta", ".", "ViewURL", ",", "Content", ":", "[", "]", "byte", "(", "it", ".", "Content", ")", ",", "Formatter", ":", "it", ".", "FormatSpec", ".", "Formatter", ",", "FormatData", ":", "[", "]", "byte", "(", "it", ".", "FormatSpec", ".", "Data", ")", ",", "}", "\n", "}" ]

[ "MakeValueItem", "builds", "a", "caching", "ValueItem", "from", "a", "config", ".", "Config", "." ]

[ "func", "(", "vi", "*", "ValueItem", ")", "ConfigItem", "(", ")", "*", "config", ".", "Config", "{", "return", "&", "config", ".", "Config", "{", "Meta", ":", "config", ".", "Meta", "{", "ConfigSet", ":", "config", ".", "Set", "(", "vi", ".", "ConfigSet", ")", ",", "Path", ":", "vi", ".", "Path", ",", "ContentHash", ":", "vi", ".", "ContentHash", ",", "Revision", ":", "vi", ".", "Revision", ",", "ViewURL", ":", "vi", ".", "ViewURL", ",", "}", ",", "Content", ":", "string", "(", "vi", ".", "Content", ")", ",", "FormatSpec", ":", "config", ".", "FormatSpec", "{", "vi", ".", "Formatter", ",", "string", "(", "vi", ".", "FormatData", ")", "}", ",", "}", "\n", "}" ]

[ "ConfigItem", "returns", "the", "config", ".", "Config", "equivalent", "of", "vi", "." ]

[ "func", "(", "vi", "*", "ValueItem", ")", "descriptionToken", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "vi", ".", "ConfigSet", ",", "vi", ".", "Path", ",", "vi", ".", "Revision", ")", "\n", "}" ]

[ "descriptionToken", "returns", "a", "human", "-", "readable", "string", "describing", "the", "contents", "of", "this", "item", "." ]

[ "func", "(", "v", "*", "Value", ")", "LoadItems", "(", "items", "...", "*", "config", ".", "Config", ")", "{", "if", "len", "(", "items", ")", "==", "0", "{", "v", ".", "Items", "=", "nil", "\n", "return", "\n", "}", "\n\n", "v", ".", "Items", "=", "make", "(", "[", "]", "ValueItem", ",", "len", "(", "items", ")", ")", "\n", "for", "i", ",", "it", ":=", "range", "items", "{", "v", ".", "Items", "[", "i", "]", "=", "MakeValueItem", "(", "it", ")", "\n", "}", "\n", "}" ]

[ "LoadItems", "loads", "a", "set", "of", "config", ".", "Config", "into", "v", "s", "Items", "field", ".", "If", "items", "is", "nil", "v", ".", "Items", "will", "be", "nil", "." ]

[ "func", "(", "v", "*", "Value", ")", "SingleItem", "(", ")", "*", "config", ".", "Config", "{", "if", "len", "(", "v", ".", "Items", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "v", ".", "Items", "[", "0", "]", ".", "ConfigItem", "(", ")", "\n", "}" ]

[ "SingleItem", "returns", "the", "first", "config", ".", "Config", "in", "v", "s", "Items", "slice", ".", "If", "the", "Items", "slice", "is", "empty", "SingleItem", "will", "return", "nil", "." ]

[ "func", "(", "v", "*", "Value", ")", "ConfigItems", "(", ")", "[", "]", "*", "config", ".", "Config", "{", "if", "len", "(", "v", ".", "Items", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "res", ":=", "make", "(", "[", "]", "*", "config", ".", "Config", ",", "len", "(", "v", ".", "Items", ")", ")", "\n", "for", "i", ":=", "range", "v", ".", "Items", "{", "res", "[", "i", "]", "=", "v", ".", "Items", "[", "i", "]", ".", "ConfigItem", "(", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "ConfigItems", "returns", "the", "config", ".", "Config", "projection", "of", "v", "s", "Items", "slice", "." ]

[ "func", "DecodeValue", "(", "d", "[", "]", "byte", ")", "(", "*", "Value", ",", "error", ")", "{", "var", "v", "Value", "\n", "if", "err", ":=", "Decode", "(", "d", ",", "&", "v", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "&", "v", ",", "nil", "\n", "}" ]

[ "DecodeValue", "loads", "a", "Value", "from", "is", "encoded", "representation", "." ]

[ "func", "(", "v", "*", "Value", ")", "Description", "(", ")", "string", "{", "parts", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "v", ".", "Items", ")", ")", "\n", "for", "_", ",", "it", ":=", "range", "v", ".", "Items", "{", "parts", "=", "append", "(", "parts", ",", "it", ".", "descriptionToken", "(", ")", ")", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "parts", ",", "\"", "\"", ")", "\n", "}" ]

[ "Description", "returns", "a", "human", "-", "readable", "string", "describing", "the", "contents", "of", "this", "value", "." ]

[ "func", "(", "b", "*", "Backend", ")", "GetAll", "(", "c", "context", ".", "Context", ",", "t", "backend", ".", "GetAllTarget", ",", "path", "string", ",", "p", "backend", ".", "Params", ")", "(", "[", "]", "*", "config", ".", "Config", ",", "error", ")", "{", "key", ":=", "Key", "{", "Schema", ":", "Schema", ",", "ServiceURL", ":", "b", ".", "keyServiceURL", "(", "c", ")", ",", "Authority", ":", "p", ".", "Authority", ",", "Op", ":", "OpGetAll", ",", "Content", ":", "p", ".", "Content", ",", "Path", ":", "path", ",", "GetAllTarget", ":", "t", ",", "Formatter", ":", "p", ".", "FormatSpec", ".", "Formatter", ",", "FormatData", ":", "p", ".", "FormatSpec", ".", "Data", ",", "}", "\n", "value", ",", "err", ":=", "b", ".", "CacheGet", "(", "c", ",", "key", ",", "b", ".", "loader", ")", "\n", "if", "err", "!=", "nil", "{", "if", "b", ".", "FailOnError", "{", "log", ".", "Fields", "{", "log", ".", "ErrorKey", ":", "err", ",", "\"", "\"", ":", "p", ".", "Authority", ",", "\"", "\"", ":", "t", ",", "\"", "\"", ":", "path", ",", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "log", ".", "Fields", "{", "log", ".", "ErrorKey", ":", "err", ",", "\"", "\"", ":", "p", ".", "Authority", ",", "\"", "\"", ":", "t", ",", "\"", "\"", ":", "path", ",", "}", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "b", ".", "B", ".", "GetAll", "(", "c", ",", "t", ",", "path", ",", "p", ")", "\n", "}", "\n", "return", "value", ".", "ConfigItems", "(", ")", ",", "nil", "\n", "}" ]

[ "GetAll", "implements", "config", ".", "Backend", "." ]

[ "func", "(", "b", "*", "Backend", ")", "loader", "(", "c", "context", ".", "Context", ",", "k", "Key", ",", "v", "*", "Value", ")", "(", "*", "Value", ",", "error", ")", "{", "return", "CacheLoad", "(", "c", ",", "b", ".", "B", ",", "k", ",", "v", ")", "\n", "}" ]

[ "loader", "runs", "a", "cache", "get", "against", "the", "configured", "Base", "backend", ".", "This", "should", "be", "used", "by", "caches", "that", "do", "not", "have", "the", "cached", "value", "." ]

[ "func", "CacheLoad", "(", "c", "context", ".", "Context", ",", "b", "backend", ".", "B", ",", "k", "Key", ",", "v", "*", "Value", ")", "(", "rv", "*", "Value", ",", "err", "error", ")", "{", "switch", "k", ".", "Op", "{", "case", "OpGet", ":", "rv", ",", "err", "=", "doGet", "(", "c", ",", "b", ",", "k", ".", "ConfigSet", ",", "k", ".", "Path", ",", "v", ",", "k", ".", "Params", "(", ")", ")", "\n", "case", "OpGetAll", ":", "rv", ",", "err", "=", "doGetAll", "(", "c", ",", "b", ",", "k", ".", "GetAllTarget", ",", "k", ".", "Path", ",", "v", ",", "k", ".", "Params", "(", ")", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ",", "k", ".", "Op", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "\n", "}" ]

[ "CacheLoad", "loads", "k", "from", "backend", "b", ".", "If", "an", "existing", "cache", "value", "is", "known", "it", "should", "be", "supplied", "as", "v", ".", "Otherwise", "v", "should", "be", "nil", ".", "This", "is", "effectively", "a", "Loader", "function", "that", "is", "detached", "from", "a", "given", "cache", "instance", "." ]

[ "func", "GetEntityGroupVersion", "(", "c", "context", ".", "Context", ",", "key", "*", "ds", ".", "Key", ")", "(", "int64", ",", "error", ")", "{", "egm", ":=", "&", "EntityGroupMeta", "{", "Parent", ":", "key", ".", "Root", "(", ")", "}", "\n", "err", ":=", "ds", ".", "Get", "(", "c", ",", "egm", ")", "\n", "ret", ":=", "egm", ".", "Version", "\n", "if", "err", "==", "ds", ".", "ErrNoSuchEntity", "{", "// this is OK for callers. The version of the entity group is effectively 0", "// in this case.", "err", "=", "nil", "\n", "}", "\n", "return", "ret", ",", "err", "\n", "}" ]

[ "GetEntityGroupVersion", "returns", "the", "entity", "group", "version", "for", "the", "entity", "group", "containing", "root", ".", "If", "the", "entity", "group", "doesn", "t", "exist", "this", "function", "will", "return", "zero", "and", "a", "nil", "error", "." ]

[ "func", "PlatformForPEP425Tag", "(", "t", "*", "vpython", ".", "PEP425Tag", ")", "string", "{", "switch", "platSplit", ":=", "strings", ".", "SplitN", "(", "t", ".", "Platform", ",", "\"", "\"", ",", "2", ")", ";", "platSplit", "[", "0", "]", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "// Grab the remainder.", "//", "// Examples:", "// - linux_i686", "// - manylinux1_x86_64", "// - linux_arm64", "cpu", ":=", "\"", "\"", "\n", "if", "len", "(", "platSplit", ")", ">", "1", "{", "cpu", "=", "platSplit", "[", "1", "]", "\n", "}", "\n", "switch", "cpu", "{", "case", "\"", "\"", ":", "return", "\"", "\"", "\n", "case", "\"", "\"", ":", "return", "\"", "\"", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "return", "\"", "\"", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "return", "\"", "\"", "\n", "case", "\"", "\"", ":", "return", "\"", "\"", "\n", "default", ":", "// All remaining \"arm*\" get the \"armv6l\" CIPD platform.", "if", "strings", ".", "HasPrefix", "(", "cpu", ",", "\"", "\"", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ":", "// Grab the last token.", "//", "// Examples:", "// - macosx_10_10_intel", "// - macosx_10_10_i386", "if", "len", "(", "platSplit", ")", "==", "1", "{", "return", "\"", "\"", "\n", "}", "\n", "suffixSplit", ":=", "strings", ".", "SplitN", "(", "platSplit", "[", "1", "]", ",", "\"", "\"", ",", "-", "1", ")", "\n", "switch", "suffixSplit", "[", "len", "(", "suffixSplit", ")", "-", "1", "]", "{", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "\"", "\"", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "return", "\"", "\"", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ":", "// win32", "return", "\"", "\"", "\n", "case", "\"", "\"", ":", "// Examples:", "// - win_amd64", "if", "len", "(", "platSplit", ")", "==", "1", "{", "return", "\"", "\"", "\n", "}", "\n", "switch", "platSplit", "[", "1", "]", "{", "case", "\"", "\"", ":", "return", "\"", "\"", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "PlatformForPEP425Tag", "returns", "the", "CIPD", "platform", "inferred", "from", "a", "given", "Python", "PEP425", "tag", ".", "If", "the", "platform", "could", "not", "be", "determined", "an", "empty", "string", "will", "be", "returned", "." ]

[ "func", "(", "s", "*", "server", ")", "LoadStream", "(", "c", "context", ".", "Context", ",", "req", "*", "logdog", ".", "LoadStreamRequest", ")", "(", "*", "logdog", ".", "LoadStreamResponse", ",", "error", ")", "{", "log", ".", "Fields", "{", "\"", "\"", ":", "req", ".", "Project", ",", "\"", "\"", ":", "req", ".", "Id", ",", "}", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n\n", "id", ":=", "coordinator", ".", "HashID", "(", "req", ".", "Id", ")", "\n", "if", "err", ":=", "id", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Errf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "id", ",", "err", ")", "\n", "}", "\n\n", "ls", ":=", "&", "coordinator", ".", "LogStream", "{", "ID", ":", "coordinator", ".", "HashID", "(", "req", ".", "Id", ")", "}", "\n", "lst", ":=", "ls", ".", "State", "(", "c", ")", "\n\n", "if", "err", ":=", "ds", ".", "Get", "(", "c", ",", "lst", ",", "ls", ")", ";", "err", "!=", "nil", "{", "if", "anyNoSuchEntity", "(", "err", ")", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n\n", "// The state isn't registered, so this stream does not exist.", "return", "nil", ",", "grpcutil", ".", "Errf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ")", "\n", "}", "\n\n", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Internal", "\n", "}", "\n\n", "// The log stream and state loaded successfully.", "resp", ":=", "logdog", ".", "LoadStreamResponse", "{", "State", ":", "buildLogStreamState", "(", "ls", ",", "lst", ")", ",", "}", "\n", "if", "req", ".", "Desc", "{", "resp", ".", "Desc", "=", "ls", ".", "Descriptor", "\n", "}", "\n", "resp", ".", "ArchivalKey", "=", "lst", ".", "ArchivalKey", "\n", "resp", ".", "Age", "=", "google", ".", "NewDuration", "(", "ds", ".", "RoundTime", "(", "clock", ".", "Now", "(", "c", ")", ")", ".", "Sub", "(", "lst", ".", "Updated", ")", ")", "\n\n", "log", ".", "Fields", "{", "\"", "\"", ":", "lst", ".", "ID", "(", ")", ",", "\"", "\"", ":", "resp", ".", "State", ".", "TerminalIndex", ",", "\"", "\"", ":", "resp", ".", "State", ".", "Archived", ",", "\"", "\"", ":", "resp", ".", "State", ".", "Purged", ",", "\"", "\"", ":", "google", ".", "DurationFromProto", "(", "resp", ".", "Age", ")", ",", "\"", "\"", ":", "len", "(", "resp", ".", "ArchivalKey", ")", ",", "}", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "&", "resp", ",", "nil", "\n", "}" ]

[ "LoadStream", "loads", "the", "log", "stream", "state", "." ]

[ "func", "(", "r", "*", "GetCAStatusRPC", ")", "GetCAStatus", "(", "c", "context", ".", "Context", ",", "req", "*", "admin", ".", "GetCAStatusRequest", ")", "(", "*", "admin", ".", "GetCAStatusResponse", ",", "error", ")", "{", "// Entities to fetch.", "ca", ":=", "CA", "{", "CN", ":", "req", ".", "Cn", "}", "\n", "crl", ":=", "CRL", "{", "Parent", ":", "ds", ".", "KeyForObj", "(", "c", ",", "&", "ca", ")", "}", "\n\n", "// Fetch them at the same revision. It is fine if CRL is not there yet. Don't", "// bother doing it in parallel: GetCAStatus is used only by admins, manually.", "err", ":=", "ds", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "if", "err", ":=", "ds", ".", "Get", "(", "c", ",", "&", "ca", ")", ";", "err", "!=", "nil", "{", "return", "err", "// can be ErrNoSuchEntity", "\n", "}", "\n", "if", "err", ":=", "ds", ".", "Get", "(", "c", ",", "&", "crl", ")", ";", "err", "!=", "nil", "&&", "err", "!=", "ds", ".", "ErrNoSuchEntity", "{", "return", "err", "// only transient errors", "\n", "}", "\n", "return", "nil", "\n", "}", ",", "nil", ")", "\n", "switch", "{", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "return", "&", "admin", ".", "GetCAStatusResponse", "{", "}", ",", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "cfgMsg", ",", "err", ":=", "ca", ".", "ParseConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "&", "admin", ".", "GetCAStatusResponse", "{", "Config", ":", "cfgMsg", ",", "Cert", ":", "utils", ".", "DumpPEM", "(", "ca", ".", "Cert", ",", "\"", "\"", ")", ",", "Removed", ":", "ca", ".", "Removed", ",", "Ready", ":", "ca", ".", "Ready", ",", "AddedRev", ":", "ca", ".", "AddedRev", ",", "UpdatedRev", ":", "ca", ".", "UpdatedRev", ",", "RemovedRev", ":", "ca", ".", "RemovedRev", ",", "CrlStatus", ":", "crl", ".", "GetStatusProto", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "GetCAStatus", "returns", "configuration", "of", "some", "CA", "defined", "in", "the", "config", "." ]

[ "func", "Public", "(", "internalCAS", "cas", ".", "StorageServer", ",", "d", "*", "tq", ".", "Dispatcher", ")", "Server", "{", "impl", ":=", "&", "repoImpl", "{", "tq", ":", "d", ",", "meta", ":", "metadata", ".", "GetStorage", "(", ")", ",", "cas", ":", "internalCAS", ",", "}", "\n", "impl", ".", "registerTasks", "(", ")", "\n", "impl", ".", "registerProcessor", "(", "&", "processing", ".", "ClientExtractor", "{", "CAS", ":", "internalCAS", "}", ")", "\n", "return", "impl", "\n", "}" ]

[ "Public", "returns", "publicly", "exposed", "implementation", "of", "cipd", ".", "Repository", "service", ".", "It", "checks", "ACLs", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "registerProcessor", "(", "p", "processing", ".", "Processor", ")", "{", "if", "impl", ".", "procsMap", "==", "nil", "{", "impl", ".", "procsMap", "=", "map", "[", "string", "]", "processing", ".", "Processor", "{", "}", "\n", "}", "\n\n", "id", ":=", "p", ".", "ID", "(", ")", "\n", "if", "impl", ".", "procsMap", "[", "id", "]", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ")", ")", "\n", "}", "\n\n", "impl", ".", "procs", "=", "append", "(", "impl", ".", "procs", ",", "p", ")", "\n", "impl", ".", "procsMap", "[", "id", "]", "=", "p", "\n", "}" ]

[ "registerProcessor", "adds", "a", "new", "processor", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "packageReader", "(", "c", "context", ".", "Context", ",", "ref", "*", "api", ".", "ObjectRef", ")", "(", "*", "processing", ".", "PackageReader", ",", "error", ")", "{", "// Get slow Google Storage based ReaderAt.", "rawReader", ",", "err", ":=", "impl", ".", "cas", ".", "GetReader", "(", "c", ",", "ref", ")", "\n", "switch", "code", ":=", "grpc", ".", "Code", "(", "err", ")", ";", "{", "case", "code", "==", "codes", ".", "NotFound", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "code", "!=", "codes", ".", "OK", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Read in 512 Kb chunks, keep 2 of them buffered.", "pkg", ",", "err", ":=", "processing", ".", "NewPackageReader", "(", "iotools", ".", "NewBufferingReaderAt", "(", "rawReader", ",", "512", "*", "1024", ",", "2", ")", ",", "rawReader", ".", "Size", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "pkg", ",", "nil", "\n", "}" ]

[ "packageReader", "opens", "a", "package", "instance", "for", "reading", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "UpdatePrefixMetadata", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "PrefixMetadata", ")", "(", "resp", "*", "api", ".", "PrefixMetadata", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "// Fill in server-assigned fields.", "r", ".", "UpdateTime", "=", "google", ".", "NewTimestamp", "(", "clock", ".", "Now", "(", "c", ")", ")", "\n", "r", ".", "UpdateUser", "=", "string", "(", "auth", ".", "CurrentIdentity", "(", "c", ")", ")", "\n\n", "// Normalize and validate format of the PrefixMetadata.", "if", "err", ":=", "common", ".", "NormalizePrefixMetadata", "(", "r", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// The root metadata is not modifiable through API.", "if", "r", ".", "Prefix", "==", "\"", "\"", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Check ACLs.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Prefix", ",", "api", ".", "Role_OWNER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Transactionally check the fingerprint and update the metadata. impl.meta", "// will recalculate the new fingerprint. Note there's a small chance the", "// caller no longer has OWNER role to modify the metadata inside the", "// transaction. We ignore it. It happens when caller's permissions are revoked", "// by someone else exactly during UpdatePrefixMetadata call.", "return", "impl", ".", "meta", ".", "UpdateMetadata", "(", "c", ",", "r", ".", "Prefix", ",", "func", "(", "cur", "*", "api", ".", "PrefixMetadata", ")", "error", "{", "if", "cur", ".", "Fingerprint", "!=", "r", ".", "Fingerprint", "{", "switch", "{", "case", "cur", ".", "Fingerprint", "==", "\"", "\"", ":", "// The metadata was deleted while the caller was messing with it.", "return", "noMetadataErr", "(", "r", ".", "Prefix", ")", "\n", "case", "r", ".", "Fingerprint", "==", "\"", "\"", ":", "// Caller tries to make a new one, but we already have it.", "return", "status", ".", "Errorf", "(", "codes", ".", "AlreadyExists", ",", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "r", ".", "Prefix", ",", "cur", ".", "Fingerprint", ")", "\n", "default", ":", "// The fingerprint has changed while the caller was messing with", "// the metadata.", "return", "status", ".", "Errorf", "(", "codes", ".", "FailedPrecondition", ",", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "r", ".", "Prefix", ",", "r", ".", "Fingerprint", ",", "cur", ".", "Fingerprint", ")", "\n", "}", "\n", "}", "\n", "prev", ":=", "*", "cur", "\n", "*", "cur", "=", "*", "r", "\n", "return", "model", ".", "EmitMetadataEvents", "(", "c", ",", "&", "prev", ",", "cur", ")", "\n", "}", ")", "\n", "}" ]

[ "UpdatePrefixMetadata", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "GetRolesInPrefix", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "PrefixRequest", ")", "(", "resp", "*", "api", ".", "RolesInPrefixResponse", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "r", ".", "Prefix", ",", "err", "=", "common", ".", "ValidatePackagePrefix", "(", "r", ".", "Prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "metas", ",", "err", ":=", "impl", ".", "meta", ".", "GetMetadata", "(", "c", ",", "r", ".", "Prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "roles", ",", "err", ":=", "rolesInPrefix", "(", "c", ",", "metas", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "resp", "=", "&", "api", ".", "RolesInPrefixResponse", "{", "Roles", ":", "make", "(", "[", "]", "*", "api", ".", "RolesInPrefixResponse_RoleInPrefix", ",", "len", "(", "roles", ")", ")", ",", "}", "\n", "for", "i", ",", "r", ":=", "range", "roles", "{", "resp", ".", "Roles", "[", "i", "]", "=", "&", "api", ".", "RolesInPrefixResponse_RoleInPrefix", "{", "Role", ":", "r", "}", "\n", "}", "\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "GetRolesInPrefix", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "noAccessErr", "(", "c", "context", ".", "Context", ",", "prefix", "string", ")", "error", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "PermissionDenied", ",", "\"", "\"", ",", "prefix", ",", "auth", ".", "CurrentIdentity", "(", "c", ")", ")", "\n", "}" ]

[ "noAccessErr", "produces", "a", "grpc", "error", "saying", "that", "the", "given", "prefix", "doesn", "t", "exist", "or", "the", "caller", "has", "no", "access", "to", "it", ".", "This", "is", "generic", "error", "message", "that", "should", "not", "give", "away", "prefix", "presence", "to", "non", "-", "readers", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "UnhidePackage", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "PackageRequest", ")", "(", "*", "empty", ".", "Empty", ",", "error", ")", "{", "return", "impl", ".", "setPackageHidden", "(", "c", ",", "r", ",", "model", ".", "Visible", ")", "\n", "}" ]

[ "UnhidePackage", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "setPackageHidden", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "PackageRequest", ",", "hidden", "bool", ")", "(", "resp", "*", "empty", ".", "Empty", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "if", "err", ":=", "common", ".", "ValidatePackageName", "(", "r", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Package", ",", "api", ".", "Role_OWNER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "switch", "err", ":=", "model", ".", "SetPackageHidden", "(", "c", ",", "r", ".", "Package", ",", "hidden", ")", ";", "{", "case", "err", "==", "datastore", ".", "ErrNoSuchEntity", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ")", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "&", "empty", ".", "Empty", "{", "}", ",", "nil", "\n", "}" ]

[ "setPackageHidden", "is", "common", "implementation", "of", "HidePackage", "and", "UnhidePackage", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "onInstanceRegistration", "(", "c", "context", ".", "Context", ",", "inst", "*", "model", ".", "Instance", ")", "error", "{", "// Collect IDs of applicable processors.", "var", "procs", "[", "]", "string", "\n", "for", "_", ",", "p", ":=", "range", "impl", ".", "procs", "{", "if", "p", ".", "Applicable", "(", "inst", ")", "{", "procs", "=", "append", "(", "procs", ",", "p", ".", "ID", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "procs", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Mark the instance as being processed now.", "inst", ".", "ProcessorsPending", "=", "procs", "\n\n", "// Launch the TQ task that does the processing (see runProcessorsTask below).", "return", "impl", ".", "tq", ".", "AddTask", "(", "c", ",", "&", "tq", ".", "Task", "{", "Payload", ":", "&", "tasks", ".", "RunProcessors", "{", "Instance", ":", "inst", ".", "Proto", "(", ")", "}", ",", "Title", ":", "inst", ".", "InstanceID", ",", "}", ")", "\n", "}" ]

[ "onInstanceRegistration", "is", "called", "in", "a", "txn", "when", "registering", "an", "instance", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "runProcessorsTask", "(", "c", "context", ".", "Context", ",", "t", "*", "tasks", ".", "RunProcessors", ")", "error", "{", "// Fetch the instance to see what processors are still pending.", "inst", ":=", "(", "&", "model", ".", "Instance", "{", "}", ")", ".", "FromProto", "(", "c", ",", "t", ".", "Instance", ")", "\n", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "inst", ")", ";", "{", "case", "err", "==", "datastore", ".", "ErrNoSuchEntity", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "inst", ".", "InstanceID", ")", "\n", "case", "err", "!=", "nil", ":", "return", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n\n", "results", ":=", "map", "[", "string", "]", "processing", ".", "Result", "{", "}", "\n\n", "// Grab processors we haven't ran yet.", "var", "run", "[", "]", "processing", ".", "Processor", "\n", "for", "_", ",", "id", ":=", "range", "inst", ".", "ProcessorsPending", "{", "if", "proc", ":=", "impl", ".", "procsMap", "[", "id", "]", ";", "proc", "!=", "nil", "{", "run", "=", "append", "(", "run", ",", "proc", ")", "\n", "}", "else", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "id", ")", "\n", "results", "[", "id", "]", "=", "processing", ".", "Result", "{", "Err", ":", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "}", "\n", "}", "\n", "}", "\n\n", "// Exit early if there's nothing to run.", "if", "len", "(", "run", ")", "==", "0", "{", "return", "impl", ".", "updateProcessors", "(", "c", ",", "t", ".", "Instance", ",", "results", ")", "\n", "}", "\n\n", "// Open the package for reading.", "pkg", ",", "err", ":=", "impl", ".", "packageReader", "(", "c", ",", "t", ".", "Instance", ".", "Instance", ")", "\n", "switch", "{", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "return", "err", "// retry the whole thing", "\n", "case", "err", "!=", "nil", ":", "// The package is fatally broken, give up.", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "for", "_", ",", "proc", ":=", "range", "run", "{", "results", "[", "proc", ".", "ID", "(", ")", "]", "=", "processing", ".", "Result", "{", "Err", ":", "err", "}", "\n", "}", "\n", "return", "impl", ".", "updateProcessors", "(", "c", ",", "t", ".", "Instance", ",", "results", ")", "\n", "}", "\n\n", "// Run the processors sequentially, since PackageReader is not very friendly", "// to concurrent access.", "var", "transientErrs", "errors", ".", "MultiError", "\n", "for", "_", ",", "proc", ":=", "range", "run", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "proc", ".", "ID", "(", ")", ")", "\n", "res", ",", "err", ":=", "proc", ".", "Run", "(", "c", ",", "inst", ",", "pkg", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "proc", ".", "ID", "(", ")", ")", "\n", "transientErrs", "=", "append", "(", "transientErrs", ",", "err", ")", "\n", "}", "else", "{", "if", "res", ".", "Err", "!=", "nil", "{", "logging", ".", "WithError", "(", "res", ".", "Err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "proc", ".", "ID", "(", ")", ")", "\n", "}", "\n", "results", "[", "proc", ".", "ID", "(", ")", "]", "=", "res", "\n", "}", "\n", "}", "\n\n", "// Store what we've got, even if some processor may have failed to run.", "updErr", ":=", "impl", ".", "updateProcessors", "(", "c", ",", "t", ".", "Instance", ",", "results", ")", "\n\n", "// Prefer errors from processors over 'updErr' if both happen. Processor", "// errors are more interesting.", "switch", "{", "case", "len", "(", "transientErrs", ")", "!=", "0", ":", "return", "transient", ".", "Tag", ".", "Apply", "(", "transientErrs", ")", "\n", "case", "updErr", "!=", "nil", ":", "return", "updErr", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "runProcessorsTask", "executes", "a", "post", "-", "upload", "processing", "step", ".", "Returning", "a", "transient", "error", "here", "causes", "the", "task", "queue", "service", "to", "retry", "the", "task", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "paginatedQuery", "(", "c", "context", ".", "Context", ",", "opts", "paginatedQueryOpts", ")", "(", "out", "[", "]", "*", "api", ".", "Instance", ",", "nextTok", "string", ",", "err", "error", ")", "{", "// Validate the request, decode the cursor.", "if", "err", ":=", "common", ".", "ValidatePackageName", "(", "opts", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "switch", "{", "case", "opts", ".", "PageSize", "<", "0", ":", "return", "nil", ",", "\"", "\"", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "opts", ".", "PageSize", ")", "\n", "case", "opts", ".", "PageSize", "==", "0", ":", "opts", ".", "PageSize", "=", "100", "\n", "}", "\n\n", "var", "cursor", "datastore", ".", "Cursor", "\n", "if", "opts", ".", "PageToken", "!=", "\"", "\"", "{", "if", "cursor", ",", "err", "=", "datastore", ".", "DecodeCursor", "(", "c", ",", "opts", ".", "PageToken", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "Validator", "!=", "nil", "{", "if", "err", ":=", "opts", ".", "Validator", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "\n\n", "// Check ACLs.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "opts", ".", "Package", ",", "api", ".", "Role_READER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// Check that the package is registered.", "if", "err", ":=", "model", ".", "CheckPackageExists", "(", "c", ",", "opts", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// Do the actual listing.", "inst", ",", "cursor", ",", "err", ":=", "opts", ".", "Handler", "(", "cursor", ",", "opts", ".", "PageSize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Convert results to proto.", "out", "=", "make", "(", "[", "]", "*", "api", ".", "Instance", ",", "len", "(", "inst", ")", ")", "\n", "for", "i", ",", "ent", ":=", "range", "inst", "{", "out", "[", "i", "]", "=", "ent", ".", "Proto", "(", ")", "\n", "}", "\n", "if", "cursor", "!=", "nil", "{", "nextTok", "=", "cursor", ".", "String", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "paginatedQuery", "is", "a", "common", "part", "of", "ListInstances", "and", "SearchInstances", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "ListInstances", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "ListInstancesRequest", ")", "(", "resp", "*", "api", ".", "ListInstancesResponse", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "result", ",", "nextPage", ",", "err", ":=", "impl", ".", "paginatedQuery", "(", "c", ",", "paginatedQueryOpts", "{", "Package", ":", "r", ".", "Package", ",", "PageSize", ":", "r", ".", "PageSize", ",", "PageToken", ":", "r", ".", "PageToken", ",", "Handler", ":", "func", "(", "cur", "datastore", ".", "Cursor", ",", "pageSize", "int32", ")", "(", "[", "]", "*", "model", ".", "Instance", ",", "datastore", ".", "Cursor", ",", "error", ")", "{", "return", "model", ".", "ListInstances", "(", "c", ",", "r", ".", "Package", ",", "pageSize", ",", "cur", ")", "\n", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "api", ".", "ListInstancesResponse", "{", "Instances", ":", "result", ",", "NextPageToken", ":", "nextPage", ",", "}", ",", "nil", "\n", "}" ]

[ "ListInstances", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "SearchInstances", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "SearchInstancesRequest", ")", "(", "resp", "*", "api", ".", "SearchInstancesResponse", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "result", ",", "nextPage", ",", "err", ":=", "impl", ".", "paginatedQuery", "(", "c", ",", "paginatedQueryOpts", "{", "Package", ":", "r", ".", "Package", ",", "PageSize", ":", "r", ".", "PageSize", ",", "PageToken", ":", "r", ".", "PageToken", ",", "Validator", ":", "func", "(", ")", "error", "{", "return", "validateTagList", "(", "r", ".", "Tags", ")", "}", ",", "Handler", ":", "func", "(", "cur", "datastore", ".", "Cursor", ",", "pageSize", "int32", ")", "(", "[", "]", "*", "model", ".", "Instance", ",", "datastore", ".", "Cursor", ",", "error", ")", "{", "return", "model", ".", "SearchInstances", "(", "c", ",", "r", ".", "Package", ",", "r", ".", "Tags", ",", "pageSize", ",", "cur", ")", "\n", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "api", ".", "SearchInstancesResponse", "{", "Instances", ":", "result", ",", "NextPageToken", ":", "nextPage", ",", "}", ",", "nil", "\n", "}" ]

[ "SearchInstances", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "DeleteRef", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "DeleteRefRequest", ")", "(", "resp", "*", "empty", ".", "Empty", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "// Validate the request.", "if", "err", ":=", "common", ".", "ValidatePackageRef", "(", "r", ".", "Name", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "common", ".", "ValidatePackageName", "(", "r", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Check ACLs.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Package", ",", "api", ".", "Role_WRITER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Verify the package actually exists, per DeleteRef contract.", "if", "err", ":=", "model", ".", "CheckPackageExists", "(", "c", ",", "r", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Actually delete the ref.", "if", "err", ":=", "model", ".", "DeleteRef", "(", "c", ",", "r", ".", "Package", ",", "r", ".", "Name", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "empty", ".", "Empty", "{", "}", ",", "nil", "\n", "}" ]

[ "DeleteRef", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "ListRefs", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "ListRefsRequest", ")", "(", "resp", "*", "api", ".", "ListRefsResponse", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "// Validate the request.", "if", "err", ":=", "common", ".", "ValidatePackageName", "(", "r", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Check ACLs.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Package", ",", "api", ".", "Role_READER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Verify the package actually exists, per ListPackageRefs contract.", "if", "err", ":=", "model", ".", "CheckPackageExists", "(", "c", ",", "r", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Actually list refs.", "refs", ",", "err", ":=", "model", ".", "ListPackageRefs", "(", "c", ",", "r", ".", "Package", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "resp", "=", "&", "api", ".", "ListRefsResponse", "{", "Refs", ":", "make", "(", "[", "]", "*", "api", ".", "Ref", ",", "len", "(", "refs", ")", ")", "}", "\n", "for", "i", ",", "ref", ":=", "range", "refs", "{", "resp", ".", "Refs", "[", "i", "]", "=", "ref", ".", "Proto", "(", ")", "\n", "}", "\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "ListRefs", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "AttachTags", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "AttachTagsRequest", ")", "(", "resp", "*", "empty", ".", "Empty", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "// Validate the request.", "if", "err", ":=", "validateMultiTagReq", "(", "r", ".", "Package", ",", "r", ".", "Instance", ",", "r", ".", "Tags", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Check ACLs.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Package", ",", "api", ".", "Role_WRITER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Actually attach the tags. This will also transactionally check the instance", "// exists and it has passed the processing successfully.", "inst", ":=", "&", "model", ".", "Instance", "{", "InstanceID", ":", "common", ".", "ObjectRefToInstanceID", "(", "r", ".", "Instance", ")", ",", "Package", ":", "model", ".", "PackageKey", "(", "c", ",", "r", ".", "Package", ")", ",", "}", "\n", "if", "err", ":=", "model", ".", "AttachTags", "(", "c", ",", "inst", ",", "r", ".", "Tags", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "empty", ".", "Empty", "{", "}", ",", "nil", "\n", "}" ]

[ "AttachTags", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "DetachTags", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "DetachTagsRequest", ")", "(", "resp", "*", "empty", ".", "Empty", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "// Validate the request.", "if", "err", ":=", "validateMultiTagReq", "(", "r", ".", "Package", ",", "r", ".", "Instance", ",", "r", ".", "Tags", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Check ACLs. Note this is scoped to OWNERS, see the proto doc.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Package", ",", "api", ".", "Role_OWNER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Verify the instance exists, per DetachTags contract.", "inst", ":=", "&", "model", ".", "Instance", "{", "InstanceID", ":", "common", ".", "ObjectRefToInstanceID", "(", "r", ".", "Instance", ")", ",", "Package", ":", "model", ".", "PackageKey", "(", "c", ",", "r", ".", "Package", ")", ",", "}", "\n", "if", "err", ":=", "model", ".", "CheckInstanceExists", "(", "c", ",", "inst", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Actually detach the tags.", "if", "err", ":=", "model", ".", "DetachTags", "(", "c", ",", "inst", ",", "r", ".", "Tags", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "empty", ".", "Empty", "{", "}", ",", "nil", "\n", "}" ]

[ "DetachTags", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "GetInstanceURL", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "GetInstanceURLRequest", ")", "(", "resp", "*", "api", ".", "ObjectURL", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "// Validate the request.", "if", "err", ":=", "common", ".", "ValidatePackageName", "(", "r", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "common", ".", "ValidateObjectRef", "(", "r", ".", "Instance", ",", "common", ".", "KnownHash", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Check ACLs.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Package", ",", "api", ".", "Role_READER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Make sure this instance actually exists (without this check the caller", "// would be able to \"probe\" CAS namespace unrestricted).", "inst", ":=", "(", "&", "model", ".", "Instance", "{", "}", ")", ".", "FromProto", "(", "c", ",", "&", "api", ".", "Instance", "{", "Package", ":", "r", ".", "Package", ",", "Instance", ":", "r", ".", "Instance", ",", "}", ")", "\n", "if", "err", ":=", "model", ".", "CheckInstanceExists", "(", "c", ",", "inst", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Ask CAS generate an URL for us. Note that CAS does caching internally.", "return", "impl", ".", "cas", ".", "GetObjectURL", "(", "c", ",", "&", "api", ".", "GetObjectURLRequest", "{", "Object", ":", "r", ".", "Instance", ",", "}", ")", "\n", "}" ]

[ "GetInstanceURL", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "impl", "*", "repoImpl", ")", "DescribeClient", "(", "c", "context", ".", "Context", ",", "r", "*", "api", ".", "DescribeClientRequest", ")", "(", "resp", "*", "api", ".", "DescribeClientResponse", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "}", "(", ")", "\n\n", "// Validate the request.", "if", "err", ":=", "common", ".", "ValidatePackageName", "(", "r", ".", "Package", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "!", "processing", ".", "IsClientPackage", "(", "r", ".", "Package", ")", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "common", ".", "ValidateObjectRef", "(", "r", ".", "Instance", ",", "common", ".", "KnownHash", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Check ACLs.", "if", "_", ",", "err", ":=", "impl", ".", "checkRole", "(", "c", ",", "r", ".", "Package", ",", "api", ".", "Role_READER", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Make sure this instance exists, has all processors finished and fetch", "// basic details about it.", "inst", ":=", "(", "&", "model", ".", "Instance", "{", "}", ")", ".", "FromProto", "(", "c", ",", "&", "api", ".", "Instance", "{", "Package", ":", "r", ".", "Package", ",", "Instance", ":", "r", ".", "Instance", ",", "}", ")", "\n", "if", "err", ":=", "model", ".", "CheckInstanceReady", "(", "c", ",", "inst", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Grab the location of the extracted CIPD client from the post-processor.", "// This must succeed, since CheckInstanceReady above verified processors have", "// finished. Thus treat any error here as internal, as it will require an", "// investigation.", "proc", ",", "err", ":=", "processing", ".", "GetClientExtractorResult", "(", "c", ",", "inst", ".", "Proto", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "grpcutil", ".", "InternalTag", ")", ".", "Err", "(", ")", "\n", "}", "\n", "ref", ",", "err", ":=", "proc", ".", "ToObjectRef", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "grpcutil", ".", "InternalTag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// refAliases (and SHA1 in particular, as hash supported by oldest code) is", "// required to allow older clients to self-update to a newer client. See the", "// doc for DescribeClientResponse proto message.", "refAliases", ":=", "proc", ".", "ObjectRefAliases", "(", ")", "\n", "sha1", ":=", "\"", "\"", "\n", "for", "_", ",", "ref", ":=", "range", "refAliases", "{", "if", "ref", ".", "HashAlgo", "==", "api", ".", "HashAlgo_SHA1", "{", "sha1", "=", "ref", ".", "HexDigest", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "sha1", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Tag", "(", "grpcutil", ".", "InternalTag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Grab the signed URL of the client binary.", "signedURL", ",", "err", ":=", "impl", ".", "cas", ".", "GetObjectURL", "(", "c", ",", "&", "api", ".", "GetObjectURLRequest", "{", "Object", ":", "ref", ",", "DownloadFilename", ":", "processing", ".", "GetClientBinaryName", "(", "r", ".", "Package", ")", ",", "// e.g. 'cipd.exe'", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "grpcutil", ".", "InternalTag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "return", "&", "api", ".", "DescribeClientResponse", "{", "Instance", ":", "inst", ".", "Proto", "(", ")", ",", "ClientRef", ":", "ref", ",", "ClientBinary", ":", "signedURL", ",", "ClientSize", ":", "proc", ".", "ClientBinary", ".", "Size", ",", "LegacySha1", ":", "sha1", ",", "ClientRefAliases", ":", "refAliases", ",", "}", ",", "nil", "\n", "}" ]

[ "DescribeClient", "implements", "the", "corresponding", "RPC", "method", "see", "the", "proto", "doc", "." ]

[ "func", "(", "l", "*", "legacyInstance", ")", "FromInstance", "(", "inst", "*", "api", ".", "Instance", ")", "*", "legacyInstance", "{", "l", ".", "PackageName", "=", "inst", ".", "Package", "\n", "l", ".", "InstanceID", "=", "common", ".", "ObjectRefToInstanceID", "(", "inst", ".", "Instance", ")", "\n", "l", ".", "RegisteredBy", "=", "inst", ".", "RegisteredBy", "\n", "if", "ts", ":=", "inst", ".", "RegisteredTs", ";", "ts", "!=", "nil", "{", "l", ".", "RegisteredTs", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ts", ".", "Seconds", "*", "1e6", "+", "int64", "(", "ts", ".", "Nanos", "/", "1e3", ")", ")", "\n", "}", "else", "{", "l", ".", "RegisteredTs", "=", "\"", "\"", "\n", "}", "\n", "return", "l", "\n", "}" ]

[ "FromInstance", "fills", "in", "legacyInstance", "based", "on", "data", "from", "Instance", "proto", "." ]

[ "func", "replyWithJSON", "(", "w", "http", ".", "ResponseWriter", ",", "obj", "interface", "{", "}", ")", "error", "{", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "enc", ":=", "json", ".", "NewEncoder", "(", "w", ")", "\n", "enc", ".", "SetIndent", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "enc", ".", "SetEscapeHTML", "(", "false", ")", "\n", "return", "enc", ".", "Encode", "(", "obj", ")", "\n", "}" ]

[ "replyWithJSON", "sends", "StatusOK", "with", "JSON", "body", "." ]

[ "func", "replyWithError", "(", "w", "http", ".", "ResponseWriter", ",", "status", ",", "message", "string", ",", "args", "...", "interface", "{", "}", ")", "error", "{", "return", "replyWithJSON", "(", "w", ",", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "status", ",", "\"", "\"", ":", "fmt", ".", "Sprintf", "(", "message", ",", "args", "...", ")", ",", "}", ")", "\n", "}" ]

[ "replyWithError", "sends", "StatusOK", "with", "JSON", "body", "containing", "an", "error", ".", "Due", "to", "Cloud", "Endpoints", "limitations", "legacy", "API", "used", "StatusOK", "for", "some", "not", "-", "OK", "responses", "and", "communicated", "the", "actual", "error", "through", "status", "response", "field", "." ]

[ "func", "setConnected", "(", "c", "context", ".", "Context", ",", "id", ",", "hostname", "string", ",", "at", "time", ".", "Time", ")", "error", "{", "// Check dscache in case vm.Connected is set now, to avoid a costly transaction.", "vm", ":=", "&", "model", ".", "VM", "{", "ID", ":", "id", ",", "}", "\n", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "vm", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "vm", ".", "Hostname", "!=", "hostname", ":", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "hostname", ")", ".", "Err", "(", ")", "\n", "case", "vm", ".", "Connected", ">", "0", ":", "return", "nil", "\n", "}", "\n", "return", "datastore", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "vm", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "vm", ".", "Hostname", "!=", "hostname", ":", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "hostname", ")", ".", "Err", "(", ")", "\n", "case", "vm", ".", "Connected", ">", "0", ":", "return", "nil", "\n", "}", "\n", "vm", ".", "Connected", "=", "at", ".", "Unix", "(", ")", "\n", "if", "err", ":=", "datastore", ".", "Put", "(", "c", ",", "vm", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ",", "nil", ")", "\n", "}" ]

[ "setConnected", "sets", "the", "Swarming", "bot", "as", "connected", "in", "the", "datastore", "if", "it", "isn", "t", "already", "." ]

[ "func", "manageMissingBot", "(", "c", "context", ".", "Context", ",", "vm", "*", "model", ".", "VM", ")", "error", "{", "// Set that the bot has not yet connected to Swarming.", "switch", "{", "case", "vm", ".", "Lifetime", ">", "0", "&&", "vm", ".", "Created", "+", "vm", ".", "Lifetime", "<", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "vm", ".", "Created", "+", "vm", ".", "Lifetime", ")", "\n", "return", "destroyInstanceAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "URL", ")", "\n", "case", "vm", ".", "Drained", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "destroyInstanceAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "URL", ")", "\n", "case", "vm", ".", "Timeout", ">", "0", "&&", "vm", ".", "Created", "+", "vm", ".", "Timeout", "<", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "vm", ".", "Created", "+", "vm", ".", "Timeout", ")", "\n", "return", "destroyInstanceAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "URL", ")", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}" ]

[ "manageMissingBot", "manages", "a", "missing", "Swarming", "bot", "." ]

[ "func", "manageExistingBot", "(", "c", "context", ".", "Context", ",", "bot", "*", "swarming", ".", "SwarmingRpcsBotInfo", ",", "vm", "*", "model", ".", "VM", ")", "error", "{", "// This value of vm.Connected may be several seconds old, because the VM was fetched", "// prior to sending an RPC to Swarming. Still, check it here to save a costly operation", "// in setConnected, since manageExistingBot may be called thousands of times per minute.", "if", "vm", ".", "Connected", "==", "0", "{", "t", ",", "err", ":=", "time", ".", "Parse", "(", "utcRFC3339", ",", "bot", ".", "FirstSeenTs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "err", ":=", "setConnected", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "Hostname", ",", "t", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "// A bot connected to Swarming may be executing workload.", "// To destroy the instance, terminate the bot first to avoid interruptions.", "// Termination can be skipped if the bot is deleted, dead, or already terminated.", "switch", "{", "case", "bot", ".", "Deleted", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "destroyInstanceAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "URL", ")", "\n", "case", "bot", ".", "IsDead", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "destroyInstanceAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "URL", ")", "\n", "}", "\n", "srv", ":=", "getSwarming", "(", "c", ",", "vm", ".", "Swarming", ")", ".", "Bot", "\n", "// bot_terminate occurs when the bot starts the termination task and is normally followed", "// by task_completed and bot_shutdown. A terminated bot has no further events. Responses", "// also include the full set of dimensions when the event was recorded. Limit response size", "// by fetching only recent events, and only the type of each.", "events", ",", "err", ":=", "srv", ".", "Events", "(", "vm", ".", "Hostname", ")", ".", "Context", "(", "c", ")", ".", "Fields", "(", "\"", "\"", ")", ".", "Limit", "(", "5", ")", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "gerr", ",", "ok", ":=", "err", ".", "(", "*", "googleapi", ".", "Error", ")", ";", "ok", "{", "logErrors", "(", "c", ",", "gerr", ")", "\n", "return", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "for", "_", ",", "e", ":=", "range", "events", ".", "Items", "{", "if", "e", ".", "EventType", "==", "\"", "\"", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "destroyInstanceAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "URL", ")", "\n", "}", "\n", "}", "\n", "switch", "{", "case", "vm", ".", "Lifetime", ">", "0", "&&", "vm", ".", "Created", "+", "vm", ".", "Lifetime", "<", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "vm", ".", "Created", "+", "vm", ".", "Lifetime", ")", "\n", "return", "terminateBotAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "Hostname", ")", "\n", "case", "vm", ".", "Drained", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "terminateBotAsync", "(", "c", ",", "vm", ".", "ID", ",", "vm", ".", "Hostname", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "manageExistingBot", "manages", "an", "existing", "Swarming", "bot", "." ]

[ "func", "manageBot", "(", "c", "context", ".", "Context", ",", "payload", "proto", ".", "Message", ")", "error", "{", "task", ",", "ok", ":=", "payload", ".", "(", "*", "tasks", ".", "ManageBot", ")", "\n", "switch", "{", "case", "!", "ok", ":", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "payload", ")", ".", "Err", "(", ")", "\n", "case", "task", ".", "GetId", "(", ")", "==", "\"", "\"", ":", "return", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "vm", ":=", "&", "model", ".", "VM", "{", "ID", ":", "task", ".", "Id", ",", "}", "\n", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "vm", ")", ";", "{", "case", "err", "==", "datastore", ".", "ErrNoSuchEntity", ":", "return", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "vm", ".", "URL", "==", "\"", "\"", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "vm", ".", "Hostname", ")", "\n", "return", "nil", "\n", "}", "\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "vm", ".", "Hostname", ",", "vm", ".", "Swarming", ")", "\n", "bot", ",", "err", ":=", "getSwarming", "(", "c", ",", "vm", ".", "Swarming", ")", ".", "Bot", ".", "Get", "(", "vm", ".", "Hostname", ")", ".", "Context", "(", "c", ")", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "gerr", ",", "ok", ":=", "err", ".", "(", "*", "googleapi", ".", "Error", ")", ";", "ok", "{", "if", "gerr", ".", "Code", "==", "http", ".", "StatusNotFound", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "manageMissingBot", "(", "c", ",", "vm", ")", "\n", "}", "\n", "logErrors", "(", "c", ",", "gerr", ")", "\n", "return", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "manageExistingBot", "(", "c", ",", "bot", ",", "vm", ")", "\n", "}" ]

[ "manageBot", "manages", "a", "Swarming", "bot", "." ]

[ "func", "terminateBotAsync", "(", "c", "context", ".", "Context", ",", "id", ",", "hostname", "string", ")", "error", "{", "t", ":=", "&", "tq", ".", "Task", "{", "Payload", ":", "&", "tasks", ".", "TerminateBot", "{", "Id", ":", "id", ",", "Hostname", ":", "hostname", ",", "}", ",", "}", "\n", "if", "err", ":=", "getDispatcher", "(", "c", ")", ".", "AddTask", "(", "c", ",", "t", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "terminateBotAsync", "schedules", "a", "task", "queue", "task", "to", "terminate", "a", "Swarming", "bot", "." ]

[ "func", "terminateBot", "(", "c", "context", ".", "Context", ",", "payload", "proto", ".", "Message", ")", "error", "{", "task", ",", "ok", ":=", "payload", ".", "(", "*", "tasks", ".", "TerminateBot", ")", "\n", "switch", "{", "case", "!", "ok", ":", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "payload", ")", ".", "Err", "(", ")", "\n", "case", "task", ".", "GetId", "(", ")", "==", "\"", "\"", ":", "return", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "task", ".", "GetHostname", "(", ")", "==", "\"", "\"", ":", "return", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "vm", ":=", "&", "model", ".", "VM", "{", "ID", ":", "task", ".", "Id", ",", "}", "\n", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "vm", ")", ";", "{", "case", "err", "==", "datastore", ".", "ErrNoSuchEntity", ":", "return", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "vm", ".", "Hostname", "!=", "task", ".", "Hostname", ":", "// Instance is already destroyed and replaced. Don't terminate the new bot.", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "task", ".", "Hostname", ")", ".", "Err", "(", ")", "\n", "}", "\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "vm", ".", "Hostname", ",", "vm", ".", "Swarming", ")", "\n", "srv", ":=", "getSwarming", "(", "c", ",", "vm", ".", "Swarming", ")", "\n", "_", ",", "err", ":=", "srv", ".", "Bot", ".", "Terminate", "(", "vm", ".", "Hostname", ")", ".", "Context", "(", "c", ")", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "gerr", ",", "ok", ":=", "err", ".", "(", "*", "googleapi", ".", "Error", ")", ";", "ok", "{", "if", "gerr", ".", "Code", "==", "http", ".", "StatusNotFound", "{", "// Bot is already deleted.", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "logErrors", "(", "c", ",", "gerr", ")", "\n", "return", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "terminateBot", "terminates", "an", "existing", "Swarming", "bot", "." ]

[ "func", "deleteVM", "(", "c", "context", ".", "Context", ",", "id", ",", "hostname", "string", ")", "error", "{", "vm", ":=", "&", "model", ".", "VM", "{", "ID", ":", "id", ",", "}", "\n", "return", "datastore", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "vm", ")", ";", "{", "case", "err", "==", "datastore", ".", "ErrNoSuchEntity", ":", "return", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "vm", ".", "Hostname", "!=", "hostname", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "hostname", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "datastore", ".", "Delete", "(", "c", ",", "vm", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ",", "nil", ")", "\n", "}" ]

[ "deleteVM", "deletes", "the", "given", "VM", "from", "the", "datastore", "if", "it", "exists", "." ]

[ "func", "canActAsProdX", "(", "c", "context", ".", "Context", ",", "account", "string", ")", "error", "{", "ts", ",", "err", ":=", "auth", ".", "GetTokenSource", "(", "c", ",", "auth", ".", "AsActor", ",", "auth", ".", "WithServiceAccount", "(", "account", ")", ",", "auth", ".", "WithScopes", "(", "monitor", ".", "ProdxmonScopes", "...", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "_", ",", "err", "=", "ts", ".", "Token", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "canActAsProdX", "attempts", "to", "grab", "ProdX", "scoped", "access", "token", "for", "the", "given", "account", "." ]

[ "func", "handleError", "(", "handler", "func", "(", "c", "*", "router", ".", "Context", ")", "error", ")", "func", "(", "c", "*", "router", ".", "Context", ")", "{", "return", "func", "(", "c", "*", "router", ".", "Context", ")", "{", "if", "err", ":=", "handler", "(", "c", ")", ";", "err", "!=", "nil", "{", "ErrorHandler", "(", "c", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "handleError", "is", "a", "wrapper", "for", "a", "handler", "so", "that", "the", "handler", "can", "return", "an", "error", "rather", "than", "call", "ErrorHandler", "directly", ".", "This", "should", "be", "used", "for", "handlers", "that", "render", "webpages", "." ]

[ "func", "cronHandler", "(", "handler", "func", "(", "c", "context", ".", "Context", ")", "error", ")", "func", "(", "c", "*", "router", ".", "Context", ")", "{", "return", "func", "(", "ctx", "*", "router", ".", "Context", ")", "{", "if", "err", ":=", "handler", "(", "ctx", ".", "Context", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "ctx", ".", "Context", ",", "\"", "\"", ")", "\n", "ctx", ".", "Writer", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "return", "\n", "}", "\n", "ctx", ".", "Writer", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "}", "\n", "}" ]

[ "cronHandler", "is", "a", "wrapper", "for", "cron", "handlers", "which", "do", "not", "require", "template", "rendering", "." ]

[ "func", "redirect", "(", "pathTemplate", "string", ",", "status", "int", ")", "router", ".", "Handler", "{", "if", "!", "strings", ".", "HasPrefix", "(", "pathTemplate", ",", "\"", "\"", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "func", "(", "c", "*", "router", ".", "Context", ")", "{", "parts", ":=", "strings", ".", "Split", "(", "pathTemplate", ",", "\"", "\"", ")", "\n", "for", "i", ",", "p", ":=", "range", "parts", "{", "if", "strings", ".", "HasPrefix", "(", "p", ",", "\"", "\"", ")", "{", "parts", "[", "i", "]", "=", "c", ".", "Params", ".", "ByName", "(", "p", "[", "1", ":", "]", ")", "\n", "}", "\n", "}", "\n", "u", ":=", "*", "c", ".", "Request", ".", "URL", "\n", "u", ".", "Path", "=", "strings", ".", "Join", "(", "parts", ",", "\"", "\"", ")", "\n", "http", ".", "Redirect", "(", "c", ".", "Writer", ",", "c", ".", "Request", ",", "u", ".", "String", "(", ")", ",", "status", ")", "\n", "}", "\n", "}" ]

[ "redirect", "returns", "a", "handler", "that", "responds", "with", "given", "HTTP", "status", "with", "a", "location", "specified", "by", "the", "pathTemplate", "." ]

[ "func", "(", "*", "Service", ")", "ListFreeIPs", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "ListFreeIPsRequest", ")", "(", "*", "crimson", ".", "ListIPsResponse", ",", "error", ")", "{", "switch", "{", "case", "req", ".", "Vlan", "<", "1", ":", "return", "nil", ",", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "req", ".", "PageSize", "<", "0", ":", "return", "nil", ",", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "req", ".", "PageSize", "==", "0", ":", "req", ".", "PageSize", "=", "defaultIPsPageSize", "\n", "}", "\n", "ips", ",", "err", ":=", "listFreeIPs", "(", "c", ",", "req", ".", "Vlan", ",", "req", ".", "PageSize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "crimson", ".", "ListIPsResponse", "{", "Ips", ":", "ips", ",", "}", ",", "nil", "\n", "}" ]

[ "ListFreeIPs", "handles", "a", "request", "to", "list", "free", "IP", "addresses", "." ]

[ "func", "listFreeIPs", "(", "c", "context", ".", "Context", ",", "vlan", "int64", ",", "limit", "int32", ")", "(", "[", "]", "*", "crimson", ".", "IP", ",", "error", ")", "{", "db", ":=", "database", ".", "Get", "(", "c", ")", "\n", "rows", ",", "err", ":=", "db", ".", "QueryContext", "(", "c", ",", "`\n\t\tSELECT ipv4\n\t\tFROM ips\n\t\tWHERE vlan_id = ? AND hostname_id IS NULL\n\t\tLIMIT ?\n\t`", ",", "vlan", ",", "limit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "var", "ips", "[", "]", "*", "crimson", ".", "IP", "\n", "for", "rows", ".", "Next", "(", ")", "{", "ip", ":=", "&", "crimson", ".", "IP", "{", "}", "\n", "var", "ipv4", "common", ".", "IPv4", "\n", "if", "err", "=", "rows", ".", "Scan", "(", "&", "ipv4", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "ip", ".", "Ipv4", "=", "ipv4", ".", "String", "(", ")", "\n", "ip", ".", "Vlan", "=", "vlan", "\n", "ips", "=", "append", "(", "ips", ",", "ip", ")", "\n", "}", "\n", "return", "ips", ",", "nil", "\n", "}" ]

[ "listFreeIPs", "returns", "a", "slice", "of", "free", "IP", "addresses", "in", "the", "database", "." ]

[ "func", "parseIPv4s", "(", "ips", "[", "]", "string", ")", "(", "[", "]", "int64", ",", "error", ")", "{", "ipv4s", ":=", "make", "(", "[", "]", "int64", ",", "len", "(", "ips", ")", ")", "\n", "for", "i", ",", "ip", ":=", "range", "ips", "{", "ipv4", ",", "err", ":=", "common", ".", "ParseIPv4", "(", "ip", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "ip", ")", "\n", "}", "\n", "ipv4s", "[", "i", "]", "=", "int64", "(", "ipv4", ")", "\n", "}", "\n", "return", "ipv4s", ",", "nil", "\n", "}" ]

[ "parseIPv4s", "returns", "a", "slice", "of", "int64", "IP", "addresses", "." ]

[ "func", "(", "b", "*", "BuilderSummary", ")", "SelfLink", "(", ")", "string", "{", "if", "b", "==", "nil", "{", "return", "InvalidBuilderIDURL", "\n", "}", "\n", "return", "BuilderIDLink", "(", "b", ".", "BuilderID", ",", "b", ".", "ProjectID", ")", "\n", "}" ]

[ "SelfLink", "returns", "a", "link", "to", "the", "associated", "builder", "." ]

[ "func", "BuilderIDLink", "(", "b", ",", "project", "string", ")", "string", "{", "parts", ":=", "strings", ".", "Split", "(", "b", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "!=", "3", "{", "return", "InvalidBuilderIDURL", "\n", "}", "\n\n", "switch", "source", ":=", "parts", "[", "0", "]", ";", "source", "{", "case", "\"", "\"", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "parts", "[", "1", "]", ",", "parts", "[", "2", "]", ")", "\n", "case", "\"", "\"", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "project", ",", "parts", "[", "1", "]", ",", "parts", "[", "2", "]", ")", "\n", "default", ":", "return", "InvalidBuilderIDURL", "\n", "}", "\n", "}" ]

[ "BuilderIDLink", "gets", "a", "builder", "link", "from", "builder", "ID", "and", "project", ".", "Depends", "on", "routes", ".", "go", "." ]

[ "func", "UpdateBuilderForBuild", "(", "c", "context", ".", "Context", ",", "build", "*", "BuildSummary", ")", "error", "{", "if", "datastore", ".", "CurrentTransaction", "(", "c", ")", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "build", ".", "Summary", ".", "Status", ".", "Terminal", "(", ")", "{", "// this build did not complete yet.", "// There is no new info for the builder.", "// Do not even bother starting a transaction.", "return", "nil", "\n", "}", "\n\n", "// Get or create the relevant BuilderSummary.", "builder", ":=", "&", "BuilderSummary", "{", "BuilderID", ":", "build", ".", "BuilderID", "}", "\n", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "builder", ")", ";", "{", "case", "err", "==", "datastore", ".", "ErrNoSuchEntity", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "build", ".", "BuilderID", ")", "\n", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "build", ".", "Created", ".", "Before", "(", "builder", ".", "LastFinishedCreated", ")", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "build", ".", "BuildID", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// Overwrite previous value of ProjectID in case a builder has moved to", "// another project.", "builder", ".", "ProjectID", "=", "build", ".", "ProjectID", "\n", "builder", ".", "LastFinishedBuildID", "=", "build", ".", "BuildID", "\n", "builder", ".", "LastFinishedCreated", "=", "build", ".", "Created", "\n", "builder", ".", "LastFinishedExperimental", "=", "build", ".", "Experimental", "\n", "builder", ".", "LastFinishedStatus", "=", "build", ".", "Summary", ".", "Status", "\n", "return", "datastore", ".", "Put", "(", "c", ",", "builder", ")", "\n", "}" ]

[ "UpdateBuilderForBuild", "updates", "the", "appropriate", "BuilderSummary", "for", "the", "provided", "BuildSummary", "if", "needed", ".", "In", "particular", "a", "BuilderSummary", "is", "updated", "with", "a", "BuildSummary", "if", "the", "latter", "is", "marked", "complete", "and", "has", "a", "more", "recent", "creation", "time", "than", "the", "one", "stored", "in", "the", "BuilderSummary", ".", "If", "there", "is", "no", "existing", "BuilderSummary", "for", "the", "BuildSummary", "provided", "one", "is", "created", ".", "Idempotent", ".", "c", "must", "have", "a", "current", "datastore", "transaction", "." ]

[ "func", "pageBase", "(", ")", "router", ".", "MiddlewareChain", "{", "return", "standard", ".", "Base", "(", ")", ".", "Extend", "(", "templates", ".", "WithTemplates", "(", "templateBundle", ")", ",", "auth", ".", "Authenticate", "(", "server", ".", "UsersAPIAuthMethod", "{", "}", ")", ",", ")", "\n", "}" ]

[ "pageBase", "returns", "the", "middleware", "chain", "for", "page", "handlers", "." ]

[ "func", "New", "(", "params", "Parameters", ")", "(", "*", "Client", ",", "error", ")", "{", "signer", ",", "err", ":=", "LoadX509Signer", "(", "params", ".", "PrivateKeyPath", ",", "params", ".", "CertificatePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "Client", "{", "Client", ":", "minter", ".", "NewTokenMinterPRPCClient", "(", "&", "prpc", ".", "Client", "{", "C", ":", "params", ".", "Client", ",", "Host", ":", "params", ".", "Backend", ",", "Options", ":", "&", "prpc", ".", "Options", "{", "Retry", ":", "params", ".", "Retry", ",", "Insecure", ":", "params", ".", "Insecure", ",", "}", ",", "}", ")", ",", "Signer", ":", "signer", ",", "}", ",", "nil", "\n", "}" ]

[ "New", "returns", "new", "Client", "that", "uses", "PEM", "encoded", "keys", "and", "talks", "to", "the", "server", "via", "pRPC", "." ]

[ "func", "PEP425Matches", "(", "match", "*", "vpython", ".", "PEP425Tag", ",", "tags", "[", "]", "*", "vpython", ".", "PEP425Tag", ")", "bool", "{", "// Special case: empty match matches nothing.", "if", "match", ".", "IsZero", "(", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "_", ",", "tag", ":=", "range", "tags", "{", "if", "v", ":=", "match", ".", "Python", ";", "v", "!=", "\"", "\"", "&&", "tag", ".", "Python", "!=", "v", "{", "continue", "\n", "}", "\n", "if", "v", ":=", "match", ".", "Abi", ";", "v", "!=", "\"", "\"", "&&", "tag", ".", "Abi", "!=", "v", "{", "continue", "\n", "}", "\n", "if", "v", ":=", "match", ".", "Platform", ";", "v", "!=", "\"", "\"", "&&", "tag", ".", "Platform", "!=", "v", "{", "continue", "\n", "}", "\n", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "PEP425Matches", "returns", "true", "if", "match", "matches", "at", "least", "one", "of", "the", "tags", "in", "tags", ".", "A", "match", "is", "determined", "if", "the", "non", "-", "zero", "fields", "in", "match", "equal", "the", "equivalent", "fields", "in", "a", "tag", "." ]

[ "func", "(", "v", "*", "Version", ")", "PythonBase", "(", ")", "string", "{", "switch", "{", "case", "v", ".", "IsZero", "(", ")", ":", "return", "\"", "\"", "\n", "case", "v", ".", "Minor", ">", "0", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ".", "Major", ",", "v", ".", "Minor", ")", "\n", "default", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ".", "Major", ")", "\n", "}", "\n", "}" ]

[ "PythonBase", "returns", "the", "base", "Python", "interpreter", "name", "for", "this", "version", "." ]

[ "func", "(", "v", "*", "Version", ")", "Less", "(", "other", "*", "Version", ")", "bool", "{", "switch", "{", "case", "v", ".", "Major", "<", "other", ".", "Major", ":", "return", "true", "\n", "case", "v", ".", "Major", ">", "other", ".", "Major", ":", "return", "false", "\n", "case", "v", ".", "Minor", "<", "other", ".", "Minor", ":", "return", "true", "\n", "case", "v", ".", "Minor", ">", "other", ".", "Minor", ":", "return", "false", "\n", "default", ":", "return", "(", "v", ".", "Patch", "<", "other", ".", "Patch", ")", "\n", "}", "\n", "}" ]

[ "Less", "returns", "true", "if", "v", "s", "Version", "semantically", "precedes", "other", "." ]

[ "func", "(", "q", "*", "Quest", ")", "Equals", "(", "a", "*", "Quest", ")", "bool", "{", "return", "q", "==", "a", "||", "(", "q", ".", "ID", "==", "a", ".", "ID", "&&", "proto", ".", "Equal", "(", "&", "q", ".", "Desc", ",", "&", "a", ".", "Desc", ")", "&&", "q", ".", "BuiltBy", ".", "Equals", "(", "a", ".", "BuiltBy", ")", "&&", "q", ".", "Created", ".", "Equal", "(", "a", ".", "Created", ")", ")", "\n", "}" ]

[ "Equals", "is", "true", "if", "q", "and", "a", "and", "equal", "." ]

[ "func", "QueryAttemptsForQuest", "(", "c", "context", ".", "Context", ",", "qid", "string", ")", "*", "ds", ".", "Query", "{", "from", ":=", "ds", ".", "MakeKey", "(", "c", ",", "\"", "\"", ",", "qid", "+", "\"", "\"", ")", "\n", "to", ":=", "ds", ".", "MakeKey", "(", "c", ",", "\"", "\"", ",", "qid", "+", "\"", "\"", ")", "\n", "return", "ds", ".", "NewQuery", "(", "\"", "\"", ")", ".", "Gt", "(", "\"", "\"", ",", "from", ")", ".", "Lt", "(", "\"", "\"", ",", "to", ")", "\n", "}" ]

[ "QueryAttemptsForQuest", "returns", "all", "Attempt", "objects", "that", "exist", "for", "this", "Quest", "." ]

[ "func", "(", "q", "*", "Quest", ")", "ToProto", "(", ")", "*", "dm", ".", "Quest", "{", "return", "&", "dm", ".", "Quest", "{", "Id", ":", "dm", ".", "NewQuestID", "(", "q", ".", "ID", ")", ",", "Data", ":", "q", ".", "DataProto", "(", ")", ",", "}", "\n", "}" ]

[ "ToProto", "converts", "this", "Quest", "into", "its", "display", "equivalent", "." ]

[ "func", "(", "q", "*", "Quest", ")", "DataProto", "(", ")", "*", "dm", ".", "Quest_Data", "{", "spec", ":=", "make", "(", "[", "]", "*", "dm", ".", "Quest_TemplateSpec", ",", "len", "(", "q", ".", "BuiltBy", ")", ")", "\n", "for", "i", ":=", "range", "q", ".", "BuiltBy", "{", "spec", "[", "i", "]", "=", "&", "q", ".", "BuiltBy", "[", "i", "]", "\n", "}", "\n\n", "return", "&", "dm", ".", "Quest_Data", "{", "Created", ":", "google_pb", ".", "NewTimestamp", "(", "q", ".", "Created", ")", ",", "Desc", ":", "&", "q", ".", "Desc", ",", "BuiltBy", ":", "spec", ",", "}", "\n", "}" ]

[ "DataProto", "gets", "the", "Quest", ".", "Data", "proto", "message", "for", "this", "Quest", "." ]

[ "func", "printDatacenters", "(", "tsv", "bool", ",", "datacenters", "...", "*", "crimson", ".", "Datacenter", ")", "{", "if", "len", "(", "datacenters", ")", ">", "0", "{", "p", ":=", "newStdoutPrinter", "(", "tsv", ")", "\n", "defer", "p", ".", "Flush", "(", ")", "\n", "if", "!", "tsv", "{", "p", ".", "Row", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "dc", ":=", "range", "datacenters", "{", "p", ".", "Row", "(", "dc", ".", "Name", ",", "dc", ".", "Description", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "printDatacenters", "prints", "datacenter", "data", "to", "stdout", "in", "tab", "-", "separated", "columns", "." ]

[ "func", "(", "c", "*", "GetDatacentersCmd", ")", "Run", "(", "app", "subcommands", ".", "Application", ",", "args", "[", "]", "string", ",", "env", "subcommands", ".", "Env", ")", "int", "{", "ctx", ":=", "cli", ".", "GetContext", "(", "app", ",", "c", ",", "env", ")", "\n", "client", ":=", "getClient", "(", "ctx", ")", "\n", "resp", ",", "err", ":=", "client", ".", "ListDatacenters", "(", "ctx", ",", "&", "c", ".", "req", ")", "\n", "if", "err", "!=", "nil", "{", "errors", ".", "Log", "(", "ctx", ",", "err", ")", "\n", "return", "1", "\n", "}", "\n", "printDatacenters", "(", "c", ".", "f", ".", "tsv", ",", "resp", ".", "Datacenters", "...", ")", "\n", "return", "0", "\n", "}" ]

[ "Run", "runs", "the", "command", "to", "get", "datacenters", "." ]

[ "func", "renderErr", "(", "h", "func", "(", "*", "router", ".", "Context", ")", "error", ")", "router", ".", "Handler", "{", "return", "func", "(", "ctx", "*", "router", ".", "Context", ")", "{", "err", ":=", "h", "(", "ctx", ")", "\n", "if", "err", "==", "nil", "{", "return", "\n", "}", "\n\n", "s", ",", "_", ":=", "status", ".", "FromError", "(", "err", ")", "\n", "message", ":=", "s", ".", "Message", "(", ")", "\n", "if", "message", "!=", "\"", "\"", "{", "// Convert the first rune to upper case.", "r", ",", "n", ":=", "utf8", ".", "DecodeRuneInString", "(", "message", ")", "\n", "message", "=", "string", "(", "unicode", ".", "ToUpper", "(", "r", ")", ")", "+", "message", "[", "n", ":", "]", "\n", "}", "else", "{", "message", "=", "\"", "\"", "// this should not really happen", "\n", "}", "\n\n", "ctx", ".", "Writer", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "ctx", ".", "Writer", ".", "WriteHeader", "(", "grpcutil", ".", "CodeStatus", "(", "s", ".", "Code", "(", ")", ")", ")", "\n", "templates", ".", "MustRender", "(", "ctx", ".", "Context", ",", "ctx", ".", "Writer", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "message", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "renderErr", "is", "a", "handler", "wrapper", "converts", "gRPC", "errors", "into", "HTML", "pages", "." ]

[ "func", "(", "r", "*", "URLSigningRequest", ")", "HasWork", "(", ")", "bool", "{", "return", "(", "r", ".", "Stream", "||", "r", ".", "Index", ")", "&&", "(", "r", ".", "Lifetime", ">", "0", ")", "\n", "}" ]

[ "HasWork", "returns", "true", "if", "this", "signing", "request", "actually", "has", "work", "that", "is", "requested", "." ]

[ "func", "loadConfig", "(", "path", "string", ")", "(", "config", ",", "error", ")", "{", "var", "ret", "config", "\n\n", "if", "path", "==", "\"", "\"", "{", "return", "ret", ",", "nil", "\n", "}", "\n\n", "file", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "defer", "file", ".", "Close", "(", ")", "\n\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "file", ")", "\n", "if", "err", "=", "decoder", ".", "Decode", "(", "&", "ret", ")", ";", "err", "!=", "nil", "{", "return", "ret", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "ret", ",", "nil", "\n\n", "case", "os", ".", "IsNotExist", "(", "err", ")", ":", "// The file does not exist. We don't consider this an error, since the file", "// is optional.", "return", "ret", ",", "nil", "\n\n", "default", ":", "// An unexpected failure occurred.", "return", "ret", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "loadConfig", "loads", "a", "tsmon", "JSON", "config", "from", "a", "file", "." ]

[ "func", "Wrap", "(", "c", "context", ".", "Context", ")", "context", ".", "Context", "{", "if", "_", ",", "ok", ":=", "c", ".", "(", "*", "cacheContext", ")", ";", "ok", "{", "return", "c", "\n", "}", "\n", "return", "&", "cacheContext", "{", "Context", ":", "c", "}", "\n", "}" ]

[ "Wrap", "wraps", "the", "supplied", "Context", "in", "a", "caching", "Context", ".", "All", "Value", "lookups", "will", "be", "cached", "at", "this", "level", "avoiding", "the", "expense", "of", "future", "Context", "traversals", "for", "that", "same", "key", "." ]

[ "func", "ValidateRepoURL", "(", "repoURL", "string", ")", "error", "{", "_", ",", "_", ",", "err", ":=", "ParseRepoURL", "(", "repoURL", ")", "\n", "return", "err", "\n", "}" ]

[ "ValidateRepoURL", "validates", "gitiles", "repository", "URL", "." ]

[ "func", "ParseRepoURL", "(", "repoURL", "string", ")", "(", "host", ",", "project", "string", ",", "err", "error", ")", "{", "var", "u", "*", "url", ".", "URL", "\n", "u", ",", "err", "=", "url", ".", "Parse", "(", "repoURL", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "u", ".", "Scheme", "!=", "\"", "\"", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "!", "strings", ".", "HasSuffix", "(", "u", ".", "Host", ",", "\"", "\"", ")", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "strings", ".", "Contains", "(", "u", ".", "Path", ",", "\"", "\"", ")", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "!", "strings", ".", "HasPrefix", "(", "u", ".", "Path", ",", "\"", "\"", ")", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "u", ".", "Path", "==", "\"", "\"", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "u", ".", "RawQuery", "!=", "\"", "\"", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "u", ".", "Fragment", "!=", "\"", "\"", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "default", ":", "host", "=", "u", ".", "Host", "\n", "if", "strings", ".", "HasPrefix", "(", "u", ".", "Path", ",", "\"", "\"", ")", "{", "u", ".", "Path", "=", "strings", ".", "TrimPrefix", "(", "u", ".", "Path", ",", "\"", "\"", ")", "\n", "}", "\n", "project", "=", "strings", ".", "Trim", "(", "u", ".", "Path", ",", "\"", "\"", ")", "\n", "project", "=", "strings", ".", "TrimSuffix", "(", "project", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "ParseRepoURL", "parses", "a", "Gitiles", "repository", "URL", "." ]

[ "func", "NormalizeRepoURL", "(", "repoURL", "string", ",", "auth", "bool", ")", "(", "*", "url", ".", "URL", ",", "error", ")", "{", "host", ",", "project", ",", "err", ":=", "ParseRepoURL", "(", "repoURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "u", ":=", "FormatRepoURL", "(", "host", ",", "project", ",", "auth", ")", "\n", "return", "&", "u", ",", "nil", "\n", "}" ]

[ "NormalizeRepoURL", "is", "a", "shortcut", "for", "ParseRepoURL", "and", "FormatRepoURL", "." ]

[ "func", "(", "p", "*", "MintParams", ")", "Validate", "(", ")", "error", "{", "// Check FDQN.", "fqdn", ",", "err", ":=", "p", ".", "MachineFQDN", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "chunks", ":=", "strings", ".", "SplitN", "(", "fqdn", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fqdn", ")", "\n", "}", "\n", "domain", ":=", "chunks", "[", "1", "]", "// e.g. \"us-central1-a.c.project-id.internal\"", "\n\n", "// Check DomainConfig for given domain.", "domainCfg", ":=", "domainConfig", "(", "p", ".", "Config", ",", "domain", ")", "\n", "if", "domainCfg", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "domain", ")", "\n", "}", "\n", "if", "domainCfg", ".", "MachineTokenLifetime", "<=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "domain", ")", "\n", "}", "\n\n", "// Make sure cert serial number fits into uint64. We don't support negative or", "// giant SNs.", "sn", ":=", "p", ".", "Cert", ".", "SerialNumber", "\n", "if", "sn", ".", "Sign", "(", ")", "<=", "0", "||", "sn", ".", "Cmp", "(", "maxUint64", ")", ">=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sn", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "that", "token", "minting", "parameters", "are", "allowed", "." ]

[ "func", "Mint", "(", "c", "context", ".", "Context", ",", "params", "*", "MintParams", ")", "(", "*", "tokenserver", ".", "MachineTokenBody", ",", "string", ",", "error", ")", "{", "if", "err", ":=", "params", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "fqdn", ",", "err", ":=", "params", ".", "MachineFQDN", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "// checked in Validate already", "\n", "}", "\n", "chunks", ":=", "strings", ".", "SplitN", "(", "fqdn", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "panic", "(", "\"", "\"", ")", "// checked in Validate already", "\n", "}", "\n", "cfg", ":=", "domainConfig", "(", "params", ".", "Config", ",", "chunks", "[", "1", "]", ")", "\n", "if", "cfg", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "// checked in Validate already", "\n", "}", "\n\n", "srvInfo", ",", "err", ":=", "params", ".", "Signer", ".", "ServiceInfo", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n\n", "body", ":=", "&", "tokenserver", ".", "MachineTokenBody", "{", "MachineFqdn", ":", "fqdn", ",", "IssuedBy", ":", "srvInfo", ".", "ServiceAccountName", ",", "IssuedAt", ":", "uint64", "(", "clock", ".", "Now", "(", "c", ")", ".", "Unix", "(", ")", ")", ",", "Lifetime", ":", "uint64", "(", "cfg", ".", "MachineTokenLifetime", ")", ",", "CaId", ":", "params", ".", "Config", ".", "UniqueId", ",", "CertSn", ":", "params", ".", "Cert", ".", "SerialNumber", ".", "Uint64", "(", ")", ",", "// already validated, fits uint64", "}", "\n", "signed", ",", "err", ":=", "SignToken", "(", "c", ",", "params", ".", "Signer", ",", "body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "body", ",", "signed", ",", "nil", "\n", "}" ]

[ "Mint", "generates", "a", "new", "machine", "token", "proto", "signs", "and", "serializes", "it", ".", "Returns", "its", "body", "as", "a", "proto", "and", "as", "a", "signed", "base64", "-", "encoded", "final", "token", "." ]

[ "func", "SignToken", "(", "c", "context", ".", "Context", ",", "signer", "signing", ".", "Signer", ",", "body", "*", "tokenserver", ".", "MachineTokenBody", ")", "(", "string", ",", "error", ")", "{", "s", ":=", "tokensigning", ".", "Signer", "{", "Signer", ":", "signer", ",", "SigningContext", ":", "tokenSigningContext", ",", "Encoding", ":", "base64", ".", "RawStdEncoding", ",", "Wrap", ":", "func", "(", "w", "*", "tokensigning", ".", "Unwrapped", ")", "proto", ".", "Message", "{", "return", "&", "tokenserver", ".", "MachineTokenEnvelope", "{", "TokenBody", ":", "w", ".", "Body", ",", "RsaSha256", ":", "w", ".", "RsaSHA256Sig", ",", "KeyId", ":", "w", ".", "KeyID", ",", "}", "\n", "}", ",", "}", "\n", "return", "s", ".", "SignToken", "(", "c", ",", "body", ")", "\n", "}" ]

[ "SignToken", "signs", "and", "serializes", "the", "machine", "subtoken", ".", "It", "doesn", "t", "do", "any", "validation", ".", "Assumes", "the", "prepared", "subtoken", "is", "valid", ".", "Produces", "base64", "-", "encoded", "token", "or", "a", "transient", "error", "." ]

[ "func", "(", "s", "*", "streamImpl", ")", "noMoreDataLocked", "(", ")", "bool", "{", "if", "!", "s", ".", "closed", "{", "return", "false", "\n", "}", "\n\n", "// If we have an append error, we will no longer accept or consume data.", "if", "s", ".", "appendErr", "!=", "nil", "{", "return", "true", "\n", "}", "\n\n", "var", "bufSize", "int64", "\n", "s", ".", "withParserLock", "(", "func", "(", ")", "error", "{", "bufSize", "=", "s", ".", "c", ".", "parser", ".", "bufferedBytes", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "bufSize", "==", "0", "\n", "}" ]

[ "noMoreDataLocked", "returns", "true", "if", "our", "stream", "has", "been", "closed", "and", "its", "buffer", "is", "empty", ".", "The", "stream", "s", "stateLock", "must", "be", "held", "when", "calling", "this", "method", "." ]

[ "func", "(", "s", "*", "streamImpl", ")", "nextBundleEntry", "(", "bb", "*", "builder", ",", "aggressive", "bool", ")", "bool", "{", "s", ".", "stateLock", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "stateLock", ".", "Unlock", "(", ")", "\n\n", "// If we're not drained, try and get the next bundle.", "modified", ":=", "false", "\n", "if", "!", "s", ".", "noMoreDataLocked", "(", ")", "{", "err", ":=", "error", "(", "nil", ")", "\n", "modified", ",", "err", "=", "s", ".", "nextBundleEntryLocked", "(", "bb", ",", "aggressive", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "setAppendErrorLocked", "(", "err", ")", "\n", "}", "\n\n", "if", "modified", "{", "s", ".", "signalDataConsumed", "(", ")", "\n", "}", "\n", "}", "\n\n", "// If we're drained, populate our terminal state.", "if", "s", ".", "noMoreDataLocked", "(", ")", "{", "if", "s", ".", "lastLogEntry", "!=", "nil", "{", "bb", ".", "setStreamTerminal", "(", "&", "s", ".", "c", ".", "template", ",", "s", ".", "lastLogEntry", ".", "StreamIndex", ")", "\n", "}", "\n", "s", ".", "setDrained", "(", ")", "\n", "}", "\n\n", "return", "modified", "\n", "}" ]

[ "nextBundleEntry", "generates", "bundles", "for", "this", "stream", ".", "The", "total", "bundle", "data", "size", "must", "not", "exceed", "the", "supplied", "size", ".", "If", "no", "bundle", "entry", "could", "be", "generated", "given", "the", "constraints", "nil", "will", "be", "returned", ".", "It", "is", "possible", "for", "some", "entries", "to", "be", "returned", "alongside", "an", "error", "." ]

[ "func", "(", "s", "*", "streamImpl", ")", "fixupLogEntry", "(", "prev", ",", "cur", "*", "logpb", ".", "LogEntry", ")", "error", "{", "if", "prev", "==", "nil", "{", "if", "cur", ".", "StreamIndex", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "cur", ".", "StreamIndex", ")", "\n", "}", "\n", "}", "else", "{", "if", "cur", ".", "StreamIndex", "!=", "prev", ".", "StreamIndex", "+", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "cur", ".", "StreamIndex", ",", "prev", ".", "StreamIndex", "+", "1", ")", "\n", "}", "\n\n", "if", "google", ".", "DurationFromProto", "(", "cur", ".", "TimeOffset", ")", "<", "google", ".", "DurationFromProto", "(", "prev", ".", "TimeOffset", ")", "{", "to", ":=", "*", "prev", ".", "TimeOffset", "\n", "cur", ".", "TimeOffset", "=", "&", "to", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "fixupLogEntry", "asserts", "and", "corrects", "a", "log", "entry", "s", "stream", "offset", "and", "ordering", "given", "the", "previous", "entry", "in", "the", "stream", ".", "If", "prev", "is", "nil", "that", "means", "that", "cur", "is", "expected", "to", "be", "the", "first", "log", "entry", "in", "the", "stream", "." ]

[ "func", "New", "(", "ctx", "context", ".", "Context", ",", "bundleSize", "int", ")", "output", ".", "Output", "{", "o", ":=", "logOutput", "{", "ctx", ":", "ctx", ",", "bundleSize", ":", "bundleSize", ",", "}", "\n", "o", ".", "ctx", "=", "log", ".", "SetFields", "(", "o", ".", "ctx", ",", "log", ".", "Fields", "{", "\"", "\"", ":", "&", "o", ",", "}", ")", "\n", "return", "&", "o", "\n", "}" ]

[ "New", "instantes", "a", "new", "log", "output", "instance", "." ]

[ "func", "(", "pc", "*", "P", ")", "WithMutex", "(", "key", "interface", "{", "}", ",", "fn", "func", "(", ")", ")", "{", "// Get a lock for this config key, and increment its reference.", "me", ":=", "pc", ".", "getConfigLock", "(", "key", ")", "\n", "defer", "pc", ".", "decRef", "(", "me", ",", "key", ")", "\n\n", "// Hold this lock's mutex and call \"fn\".", "me", ".", "Lock", "(", ")", "\n", "defer", "me", ".", "Unlock", "(", ")", "\n\n", "fn", "(", ")", "\n", "}" ]

[ "WithMutex", "locks", "the", "Mutex", "matching", "the", "specified", "key", "and", "executes", "fn", "while", "holding", "its", "lock", ".", "If", "a", "mutex", "for", "key", "doesn", "t", "exist", "one", "will", "be", "created", "and", "will", "be", "automatically", "cleaned", "up", "when", "no", "longer", "referenced", "." ]

[ "func", "GreedyBatchingPolicy", "(", "maxConcurrentInvs", ",", "maxBatchSize", "int", ")", "(", "Func", ",", "error", ")", "{", "return", "basePolicy", "(", "maxConcurrentInvs", ",", "maxBatchSize", ",", "func", "(", "triggers", "[", "]", "*", "internal", ".", "Trigger", ")", "int", "{", "return", "len", "(", "triggers", ")", "\n", "}", ")", "\n", "}" ]

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

[ "func", "Register", "(", "name", "string", ",", "cb", "Callback", ")", "{", "if", "name", "==", "\"", "\"", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "state", ".", "Lock", "(", ")", "\n", "defer", "state", ".", "Unlock", "(", ")", "\n", "state", ".", "callbacks", "=", "append", "(", "state", ".", "callbacks", ",", "callbackWithName", "{", "cb", ",", "name", "}", ")", "\n", "}" ]

[ "Register", "adds", "a", "callback", "called", "during", "warmup", "." ]

[ "func", "Warmup", "(", "c", "context", ".", "Context", ")", "error", "{", "state", ".", "Lock", "(", ")", "\n", "defer", "state", ".", "Unlock", "(", ")", "\n\n", "var", "merr", "errors", ".", "MultiError", "\n", "for", "_", ",", "cb", ":=", "range", "state", ".", "callbacks", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "cb", ".", "name", ")", "\n", "if", "err", ":=", "cb", ".", "Callback", "(", "c", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "cb", ".", "name", ")", "\n", "merr", "=", "append", "(", "merr", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "if", "len", "(", "merr", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "merr", "\n", "}" ]

[ "Warmup", "executes", "all", "registered", "warmup", "callbacks", "sequentially", ".", "Doesn", "t", "abort", "on", "individual", "callback", "errors", "just", "collects", "and", "returns", "them", "all", "." ]

[ "func", "prune", "(", "c", "context", ".", "Context", ",", "cfg", "*", "Config", ",", "exempt", "stringset", ".", "Set", ")", "error", "{", "pruneThreshold", ":=", "cfg", ".", "PruneThreshold", "\n", "if", "pruneThreshold", "<=", "0", "{", "// Pruning is disabled.", "return", "nil", "\n", "}", "\n\n", "now", ":=", "clock", ".", "Now", "(", "c", ")", "\n", "minPruneAge", ":=", "now", ".", "Add", "(", "-", "pruneThreshold", ")", "\n\n", "// Run a series of independent scan/prune operations.", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "cfg", ".", "BaseDir", ",", "pruneThreshold", ",", "minPruneAge", ")", "\n\n", "// Iterate over all of our VirtualEnv candidates.", "//", "// Any pruning errors will be accumulated in \"allErrs\", so ForEach will only", "// receive nil return values from the callback. This means that any error", "// returned by ForEach was an actual error with the iteration itself.", "var", "(", "allErrs", "errors", ".", "MultiError", "\n", "totalPruned", "=", "0", "\n", "hitLimitStr", "=", "\"", "\"", "\n", ")", "\n\n", "// We need to cancel if we hit our prune limit.", "c", ",", "cancelFunc", ":=", "context", ".", "WithCancel", "(", "c", ")", "\n", "defer", "cancelFunc", "(", ")", "\n\n", "// Iterate over all VirtualEnv directories, regardless of their completion", "// status.", "it", ":=", "Iterator", "{", "// Shuffle the slice randomly. We do this in case others are also processing", "// this directory simultaneously.", "Shuffle", ":", "true", ",", "}", "\n", "err", ":=", "it", ".", "ForEach", "(", "c", ",", "cfg", ",", "func", "(", "c", "context", ".", "Context", ",", "e", "*", "Env", ")", "error", "{", "if", "exempt", "!=", "nil", "&&", "exempt", ".", "Has", "(", "e", ".", "Name", ")", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "e", ".", "Name", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "ts", ",", "err", ":=", "e", ".", "completionFlagTimestamp", "(", ")", ";", "err", "==", "nil", "&&", "ts", ".", "After", "(", "minPruneAge", ")", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "e", ".", "Name", ",", "ts", ")", "\n", "return", "nil", "\n", "}", "\n\n", "switch", "err", ":=", "e", ".", "Delete", "(", "c", ")", ";", "errors", ".", "Unwrap", "(", "err", ")", "{", "case", "nil", ":", "totalPruned", "++", "\n", "if", "cfg", ".", "MaxPrunesPerSweep", ">", "0", "&&", "totalPruned", ">=", "cfg", ".", "MaxPrunesPerSweep", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "cfg", ".", "MaxPrunesPerSweep", ")", "\n", "hitLimitStr", "=", "\"", "\"", "\n", "cancelFunc", "(", ")", "\n", "}", "\n\n", "case", "fslock", ".", "ErrLockHeld", ":", "logging", ".", "WithError", "(", "err", ")", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "e", ".", "Name", ")", "\n\n", "default", ":", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "e", ".", "Name", ")", ".", "InternalReason", "(", "\"", "\"", ",", "e", ".", "Config", ".", "BaseDir", ")", ".", "Err", "(", ")", "\n", "allErrs", "=", "append", "(", "allErrs", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "// Error during iteration.", "return", "err", "\n", "}", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "totalPruned", ",", "hitLimitStr", ",", "len", "(", "allErrs", ")", ")", "\n", "if", "len", "(", "allErrs", ")", ">", "0", "{", "return", "allErrs", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "prune", "examines", "environments", "in", "cfg", "s", "BaseDir", ".", "If", "any", "are", "found", "that", "are", "older", "than", "the", "prune", "threshold", "in", "cfg", "they", "will", "be", "safely", "deleted", ".", "If", "exempt", "is", "not", "nil", "it", "contains", "a", "list", "of", "VirtualEnv", "names", "that", "will", "be", "exempted", "from", "pruning", ".", "This", "is", "used", "to", "prevent", "pruning", "from", "modifying", "environments", "that", "are", "known", "to", "be", "recently", "used", "and", "to", "completely", "avoid", "a", "case", "where", "an", "environment", "could", "be", "pruned", "while", "it", "s", "in", "use", "by", "this", "program", "." ]

[ "func", "blame", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ")", "error", "{", "if", "err", ":=", "fetchChangesCached", "(", "c", ",", "b", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "blame", ":=", "stringset", ".", "New", "(", "len", "(", "b", ".", "Sourcestamp", ".", "Changes", ")", ")", "\n", "b", ".", "Blame", "=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "b", ".", "Sourcestamp", ".", "Changes", ")", ")", "\n", "for", "_", ",", "c", ":=", "range", "b", ".", "Sourcestamp", ".", "Changes", "{", "if", "blame", ".", "Add", "(", "c", ".", "Who", ")", "{", "b", ".", "Blame", "=", "append", "(", "b", ".", "Blame", ",", "c", ".", "Who", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "blame", "loads", "changes", "from", "gitiles", "and", "computes", "b", ".", "Blame", "and", "b", ".", "SourceStamp", ".", "Changes", "from", "b", ".", "SourceStamp", ".", "Repository", "b", ".", "SourceStamp", ".", "Revision", "and", "builds", "previous", "to", "b", ".", "Memcaches", "results", "." ]

[ "func", "fetchChangesCached", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ")", "error", "{", "report", ":=", "func", "(", "err", "error", ",", "msg", "string", ")", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "b", ".", "ID", "(", ")", ",", "msg", ")", "\n", "}", "\n\n", "cache", ":=", "memcache", ".", "NewItem", "(", "c", ",", "\"", "\"", "+", "b", ".", "ID", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "err", ":=", "memcache", ".", "Get", "(", "c", ",", "cache", ")", ";", "err", "==", "nil", "{", "err", ":=", "json", ".", "Unmarshal", "(", "cache", ".", "Value", "(", ")", ",", "&", "b", ".", "Sourcestamp", ".", "Changes", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "b", ".", "Sourcestamp", ".", "Changes", "=", "nil", "\n", "report", "(", "err", ",", "\"", "\"", ")", "\n", "}", "else", "if", "err", "!=", "memcache", ".", "ErrCacheMiss", "{", "report", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "fetchChanges", "(", "c", ",", "b", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "marshaled", ",", "err", ":=", "json", ".", "Marshal", "(", "b", ".", "Sourcestamp", ".", "Changes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "len", "(", "marshaled", ")", ">", "1", "<<", "20", "{", "report", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "else", "{", "cache", ".", "SetValue", "(", "marshaled", ")", "\n", "if", "err", ":=", "memcache", ".", "Set", "(", "c", ",", "cache", ")", ";", "err", "!=", "nil", "{", "report", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "fetchChangesCached", "is", "same", "as", "fetchChanges", "but", "with", "memcaching", "." ]

[ "func", "fetchChanges", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ")", "error", "{", "memcache", ".", "Set", "(", "c", ",", "buildRevCache", "(", "c", ",", "b", ")", ")", "\n\n", "// initialize the slice so that when serialized to JSON, it is [], not null.", "b", ".", "Sourcestamp", ".", "Changes", "=", "[", "]", "buildbot", ".", "Change", "{", "}", "\n\n", "host", ",", "project", ",", "err", ":=", "gitiles", ".", "ParseRepoURL", "(", "b", ".", "Sourcestamp", ".", "Repository", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "b", ".", "ID", "(", ")", ",", "b", ".", "Sourcestamp", ".", "Repository", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "!", "commitHashRe", ".", "MatchString", "(", "b", ".", "Sourcestamp", ".", "Revision", ")", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "b", ".", "Sourcestamp", ".", "Revision", ",", "b", ".", "ID", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n\n", "prevRev", ",", "err", ":=", "getPrevRev", "(", "c", ",", "b", ",", "100", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "b", ".", "ID", "(", ")", ")", ".", "Err", "(", ")", "\n", "case", "prevRev", "==", "\"", "\"", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "b", ".", "ID", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// Note that prev build may be coming from buildbot and having commit different", "// from the true previous _LUCI_ build, which may cause blamelist to have", "// extra or missing commits. This matters only for the first build after", "// next build number bump.", "// we don't really need a blamelist with a length > 50", "commits", ",", "err", ":=", "git", ".", "Get", "(", "c", ")", ".", "Log", "(", "c", ",", "host", ",", "project", ",", "b", ".", "Sourcestamp", ".", "Revision", ",", "&", "git", ".", "LogOptions", "{", "Limit", ":", "50", "}", ")", "\n", "switch", "status", ".", "Code", "(", "err", ")", "{", "case", "codes", ".", "OK", ":", "for", "_", ",", "commit", ":=", "range", "commits", "{", "if", "commit", ".", "Id", "==", "prevRev", "{", "break", "\n", "}", "\n", "change", ":=", "changeFromGitiles", "(", "b", ".", "Sourcestamp", ".", "Repository", ",", "\"", "\"", ",", "commit", ")", "\n", "b", ".", "Sourcestamp", ".", "Changes", "=", "append", "(", "b", ".", "Sourcestamp", ".", "Changes", ",", "change", ")", "\n", "}", "\n", "return", "nil", "\n\n", "case", "codes", ".", "NotFound", ":", "logging", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "b", ".", "Sourcestamp", ".", "Repository", ",", "b", ".", "Sourcestamp", ".", "Revision", ")", "\n", "b", ".", "Sourcestamp", ".", "Changes", "=", "nil", "\n", "return", "nil", "\n\n", "default", ":", "return", "err", "\n", "}", "\n", "}" ]

[ "fetchChanges", "populates", "b", ".", "SourceStamp", ".", "Changes", "from", "Gitiles", ".", "Uses", "memcache", "to", "read", "the", "revision", "of", "the", "previous", "build", ".", "If", "not", "available", "loads", "the", "previous", "build", "that", "has", "a", "commit", "hash", "revision", "." ]

[ "func", "changeFromGitiles", "(", "repoURL", ",", "branch", "string", ",", "commit", "*", "gitpb", ".", "Commit", ")", "buildbot", ".", "Change", "{", "ct", ",", "_", ":=", "ptypes", ".", "Timestamp", "(", "commit", ".", "Committer", ".", "Time", ")", "\n", "return", "buildbot", ".", "Change", "{", "At", ":", "ct", ".", "Format", "(", "\"", "\"", ")", ",", "Branch", ":", "&", "branch", ",", "Comments", ":", "commit", ".", "Message", ",", "Repository", ":", "repoURL", ",", "Rev", ":", "commit", ".", "Id", ",", "Revision", ":", "commit", ".", "Id", ",", "Revlink", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "TrimSuffix", "(", "repoURL", ",", "\"", "\"", ")", ",", "commit", ".", "Id", ")", ",", "When", ":", "int", "(", "ct", ".", "Unix", "(", ")", ")", ",", "Who", ":", "commit", ".", "Author", ".", "Email", ",", "// TODO(nodir): add Files if someone needs them.", "}", "\n", "}" ]

[ "changeFromGitiles", "converts", "a", "gitiles", ".", "Commit", "to", "a", "buildbot", "change", "." ]

[ "func", "getPrevRev", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ",", "maxRecursionDepth", "int", ")", "(", "string", ",", "error", ")", "{", "// note: we cannot use exponential scan here because there may be build", "// number gaps anywhere, for example given build numbers 10 20 30 40,", "// if we check 25 while scanning [20, 40), we don't know if we should continue", "// scanning in [20, 25) or (25, 40).", "switch", "{", "case", "b", ".", "Number", "==", "0", ":", "return", "\"", "\"", ",", "nil", "\n", "case", "maxRecursionDepth", "<=", "0", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "\"", "\"", ",", "nil", "\n", "}", "\n\n", "prev", ":=", "&", "buildbot", ".", "Build", "{", "Master", ":", "b", ".", "Master", ",", "Buildername", ":", "b", ".", "Buildername", ",", "Number", ":", "b", ".", "Number", "-", "1", ",", "}", "\n\n", "cache", ":=", "buildRevCache", "(", "c", ",", "prev", ")", "\n", "err", ":=", "memcache", ".", "Get", "(", "c", ",", "cache", ")", "\n", "if", "err", "==", "nil", "{", "// fast path", "return", "string", "(", "cache", ".", "Value", "(", ")", ")", ",", "nil", "\n", "}", "\n\n", "// slow path", "if", "err", "!=", "memcache", ".", "ErrCacheMiss", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "cache", ".", "Key", "(", ")", ")", "\n", "}", "\n", "fetched", ",", "err", ":=", "getBuild", "(", "c", ",", "prev", ".", "ID", "(", ")", ",", "false", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "var", "prevRev", "string", "\n", "if", "fetched", "!=", "nil", "&&", "commitHashRe", ".", "MatchString", "(", "fetched", ".", "Sourcestamp", ".", "Revision", ")", "{", "prevRev", "=", "fetched", ".", "Sourcestamp", ".", "Revision", "\n", "}", "else", "{", "// slowest path", "// May happen if there is a gap in build numbers or", "// if someone scheduled a build manually with no or HEAD revision.", "// Rare case.", "// This is a recursive call of itself.", "// The results are memcached along the stack though.", "if", "prevRev", ",", "err", "=", "getPrevRev", "(", "c", ",", "b", ",", "maxRecursionDepth", "-", "1", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "\n", "cache", ".", "SetValue", "(", "[", "]", "byte", "(", "prevRev", ")", ")", "\n", "memcache", ".", "Set", "(", "c", ",", "cache", ")", "\n", "return", "prevRev", ",", "nil", "\n", "}" ]

[ "getPrevRev", "returns", "revision", "of", "the", "closest", "previous", "build", "with", "a", "commit", "hash", "or", "if", "not", "found", ".", "Memcaches", "results", "." ]

[ "func", "buildRevCache", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ")", "memcache", ".", "Item", "{", "item", ":=", "memcache", ".", "NewItem", "(", "c", ",", "\"", "\"", "+", "b", ".", "ID", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "b", ".", "Sourcestamp", "!=", "nil", "{", "item", ".", "SetValue", "(", "[", "]", "byte", "(", "b", ".", "Sourcestamp", ".", "Revision", ")", ")", "\n", "}", "\n", "return", "item", "\n", "}" ]

[ "buildRevCache", "returns", "a", "memcache", ".", "Item", "for", "the", "build", "s", "revision", ".", "Initializes", "the", "value", "with", "current", "revision", "." ]

[ "func", "SerializeDescriptor", "(", "fields", "[", "]", "Field", ")", "[", "]", "*", "pb", ".", "MetricsDataSet_MetricFieldDescriptor", "{", "ret", ":=", "make", "(", "[", "]", "*", "pb", ".", "MetricsDataSet_MetricFieldDescriptor", ",", "len", "(", "fields", ")", ")", "\n\n", "for", "i", ",", "f", ":=", "range", "fields", "{", "d", ":=", "&", "pb", ".", "MetricsDataSet_MetricFieldDescriptor", "{", "Name", ":", "proto", ".", "String", "(", "f", ".", "Name", ")", ",", "}", "\n\n", "switch", "f", ".", "Type", "{", "case", "StringType", ":", "d", ".", "FieldType", "=", "pb", ".", "MetricsDataSet_MetricFieldDescriptor_STRING", ".", "Enum", "(", ")", "\n", "case", "BoolType", ":", "d", ".", "FieldType", "=", "pb", ".", "MetricsDataSet_MetricFieldDescriptor_BOOL", ".", "Enum", "(", ")", "\n", "case", "IntType", ":", "d", ".", "FieldType", "=", "pb", ".", "MetricsDataSet_MetricFieldDescriptor_INT64", ".", "Enum", "(", ")", "\n", "}", "\n\n", "ret", "[", "i", "]", "=", "d", "\n", "}", "\n\n", "return", "ret", "\n", "}" ]

[ "SerializeDescriptor", "returns", "a", "slice", "of", "field", "descriptors", "representing", "just", "the", "names", "and", "types", "of", "fields", "." ]

[ "func", "Serialize", "(", "fields", "[", "]", "Field", ",", "values", "[", "]", "interface", "{", "}", ")", "[", "]", "*", "pb", ".", "MetricsData_MetricField", "{", "ret", ":=", "make", "(", "[", "]", "*", "pb", ".", "MetricsData_MetricField", ",", "len", "(", "fields", ")", ")", "\n\n", "for", "i", ",", "f", ":=", "range", "fields", "{", "d", ":=", "&", "pb", ".", "MetricsData_MetricField", "{", "Name", ":", "proto", ".", "String", "(", "f", ".", "Name", ")", ",", "}", "\n\n", "switch", "f", ".", "Type", "{", "case", "StringType", ":", "d", ".", "Value", "=", "&", "pb", ".", "MetricsData_MetricField_StringValue", "{", "values", "[", "i", "]", ".", "(", "string", ")", "}", "\n", "case", "BoolType", ":", "d", ".", "Value", "=", "&", "pb", ".", "MetricsData_MetricField_BoolValue", "{", "values", "[", "i", "]", ".", "(", "bool", ")", "}", "\n", "case", "IntType", ":", "d", ".", "Value", "=", "&", "pb", ".", "MetricsData_MetricField_Int64Value", "{", "values", "[", "i", "]", ".", "(", "int64", ")", "}", "\n", "}", "\n\n", "ret", "[", "i", "]", "=", "d", "\n", "}", "\n\n", "return", "ret", "\n", "}" ]

[ "Serialize", "returns", "a", "slice", "of", "ts_mon_proto", ".", "MetricsData", ".", "MetricsField", "messages", "representing", "the", "field", "names", "and", "values", "." ]

[ "func", "routeToPage", "(", "c", "*", "router", ".", "Context", ")", "error", "{", "path", ":=", "c", ".", "Params", ".", "ByName", "(", "\"", "\"", ")", "\n", "switch", "chunks", ":=", "strings", ".", "SplitN", "(", "path", ",", "\"", "\"", ",", "2", ")", ";", "{", "case", "len", "(", "chunks", ")", "<=", "1", ":", "// no '/+/' in path => prefix listing page", "return", "prefixListingPage", "(", "c", ",", "path", ")", "\n", "case", "len", "(", "chunks", ")", "==", "2", "&&", "chunks", "[", "1", "]", "==", "\"", "\"", ":", "// ends with '/+/' => package page", "return", "packagePage", "(", "c", ",", "chunks", "[", "0", "]", ")", "\n", "case", "len", "(", "chunks", ")", "==", "2", ":", "// has something after '/+/' => instance page", "return", "instancePage", "(", "c", ",", "chunks", "[", "0", "]", ",", "chunks", "[", "1", "]", ")", "\n", "default", ":", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "routeToPage", "routes", "to", "an", "appropriate", "page", "depending", "on", "the", "request", "URL", "." ]

[ "func", "(", "s", "*", "Service", ")", "FireAllTasks", "(", "c", "context", ".", "Context", ")", "error", "{", "cfg", ":=", "getConfig", "(", "c", ")", "\n\n", "namespaces", ",", "err", ":=", "s", ".", "getNamespaces", "(", "c", ",", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Probe each namespace in parallel. Each probe function reports its own", "// errors, so the work pool will never return any non-nil error response.", "var", "errCount", ",", "taskCount", "counter", "\n", "_", "=", "parallel", ".", "WorkPool", "(", "cfg", ".", "NumGoroutines", ",", "func", "(", "ch", "chan", "<-", "func", "(", ")", "error", ")", "{", "for", "_", ",", "ns", ":=", "range", "namespaces", "{", "ns", ":=", "ns", "\n", "ch", "<-", "func", "(", ")", "error", "{", "// Generate a list of all shards.", "allShards", ":=", "make", "(", "[", "]", "taskShard", ",", "0", ",", "cfg", ".", "TotalShardCount", "(", "ns", ")", ")", "\n", "for", "i", ":=", "uint64", "(", "0", ")", ";", "i", "<", "cfg", ".", "TotalShardCount", "(", "ns", ")", ";", "i", "++", "{", "allShards", "=", "append", "(", "allShards", ",", "taskShard", "{", "i", ",", "minTS", "}", ")", "\n", "}", "\n", "s", ".", "fireAllTasksForNamespace", "(", "c", ",", "cfg", ",", "ns", ",", "allShards", ",", "&", "errCount", ",", "&", "taskCount", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}", ")", "\n", "if", "errCount", ">", "0", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "errCount", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "len", "(", "namespaces", ")", ",", "taskCount", ")", "\n", "return", "err", "\n", "}" ]

[ "FireAllTasks", "searches", "for", "work", "in", "all", "namespaces", "and", "fires", "off", "a", "process", "task", "for", "any", "shards", "it", "finds", "that", "have", "at", "least", "one", "Mutation", "present", "to", "ensure", "that", "no", "work", "languishes", "forever", ".", "This", "may", "not", "be", "needed", "in", "a", "constantly", "-", "loaded", "system", "with", "good", "tumble", "key", "distribution", "." ]

[ "func", "processURL", "(", "ts", "timestamp", ",", "shard", "uint64", ",", "ns", "string", ",", "loop", "bool", ")", "string", "{", "v", ":=", "strings", ".", "NewReplacer", "(", "\"", "\"", ",", "fmt", ".", "Sprint", "(", "shard", ")", ",", "\"", "\"", ",", "strconv", ".", "FormatInt", "(", "int64", "(", "ts", ")", ",", "10", ")", ",", ")", ".", "Replace", "(", "processShardPattern", ")", "\n\n", "// Append our namespace query parameter. This is cosmetic, and the default", "// namespace will have this query parameter omitted.", "query", ":=", "url", ".", "Values", "{", "}", "\n", "if", "ns", "!=", "\"", "\"", "{", "query", ".", "Set", "(", "\"", "\"", ",", "ns", ")", "\n", "}", "\n", "if", "!", "loop", "{", "query", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "query", ")", ">", "0", "{", "v", "+=", "\"", "\"", "+", "query", ".", "Encode", "(", ")", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "processURL", "creates", "a", "new", "url", "for", "a", "process", "shard", "taskqueue", "task", "including", "the", "given", "timestamp", "and", "shard", "number", "." ]

[ "func", "(", "db", "*", "SnapshotDB", ")", "IsInternalService", "(", "c", "context", ".", "Context", ",", "hostname", "string", ")", "(", "bool", ",", "error", ")", "{", "if", "db", ".", "internalServices", "==", "nil", "{", "return", "false", ",", "nil", "\n", "}", "\n", "return", "db", ".", "internalServices", ".", "MatchString", "(", "hostname", ")", ",", "nil", "\n", "}" ]

[ "IsInternalService", "returns", "true", "if", "the", "given", "hostname", "belongs", "to", "a", "service", "that", "is", "a", "part", "of", "the", "current", "LUCI", "deployment", ".", "What", "hosts", "are", "internal", "is", "controlled", "by", "internal_service_regexp", "setting", "in", "security", ".", "cfg", "in", "the", "Auth", "Service", "configs", "." ]

[ "func", "(", "db", "*", "SnapshotDB", ")", "IsMember", "(", "c", "context", ".", "Context", ",", "id", "identity", ".", "Identity", ",", "groups", "[", "]", "string", ")", "(", "bool", ",", "error", ")", "{", "// TODO(vadimsh): Optimize multi-group case.", "for", "_", ",", "gr", ":=", "range", "groups", "{", "switch", "found", ",", "err", ":=", "db", ".", "isMemberImpl", "(", "c", ",", "id", ",", "gr", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "false", ",", "err", "\n", "case", "found", ":", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "IsMember", "returns", "true", "if", "the", "given", "identity", "belongs", "to", "any", "of", "the", "groups", ".", "Unknown", "groups", "are", "considered", "empty", ".", "May", "return", "errors", "if", "underlying", "datastore", "has", "issues", "." ]

[ "func", "(", "db", "*", "SnapshotDB", ")", "CheckMembership", "(", "c", "context", ".", "Context", ",", "id", "identity", ".", "Identity", ",", "groups", "[", "]", "string", ")", "(", "out", "[", "]", "string", ",", "err", "error", ")", "{", "// TODO(vadimsh): Optimize multi-group case.", "for", "_", ",", "gr", ":=", "range", "groups", "{", "switch", "found", ",", "err", ":=", "db", ".", "isMemberImpl", "(", "c", ",", "id", ",", "gr", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "case", "found", ":", "out", "=", "append", "(", "out", ",", "gr", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "CheckMembership", "returns", "groups", "from", "the", "given", "list", "the", "identity", "belongs", "to", ".", "Unlike", "IsMember", "it", "doesn", "t", "stop", "on", "the", "first", "hit", "but", "continues", "evaluating", "all", "groups", ".", "Unknown", "groups", "are", "considered", "empty", ".", "The", "order", "of", "groups", "in", "the", "result", "may", "be", "different", "from", "the", "order", "in", "groups", ".", "May", "return", "errors", "if", "underlying", "datastore", "has", "issues", "." ]

[ "func", "(", "db", "*", "SnapshotDB", ")", "isMemberImpl", "(", "c", "context", ".", "Context", ",", "id", "identity", ".", "Identity", ",", "groupName", "string", ")", "(", "bool", ",", "error", ")", "{", "// Cycle detection check uses a stack of groups currently being explored. Use", "// stack allocated array as a backing store to avoid unnecessary dynamic", "// allocation. If stack depth grows beyond 8, 'append' will reallocate it on", "// the heap.", "var", "backingStore", "[", "8", "]", "*", "group", "\n", "current", ":=", "backingStore", "[", ":", "0", "]", "\n\n", "// Keep a set of all visited groups to avoid revisiting them in case of a", "// diamond-like graph, e.g A -> B, A -> C, B -> D, C -> D (we don't need to", "// visit D twice in this case).", "visited", ":=", "make", "(", "map", "[", "*", "group", "]", "struct", "{", "}", ",", "10", ")", "\n\n", "// isMember is used to recurse over nested groups.", "var", "isMember", "func", "(", "*", "group", ")", "bool", "\n\n", "isMember", "=", "func", "(", "gr", "*", "group", ")", "bool", "{", "// 'id' is a direct member?", "if", "_", ",", "ok", ":=", "gr", ".", "members", "[", "id", "]", ";", "ok", "{", "return", "true", "\n", "}", "\n\n", "// 'id' matches some glob?", "for", "_", ",", "glob", ":=", "range", "gr", ".", "globs", "{", "if", "glob", ".", "Match", "(", "id", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "gr", ".", "nested", ")", "==", "0", "{", "return", "false", "\n", "}", "\n\n", "current", "=", "append", "(", "current", ",", "gr", ")", "// popped before return", "\n\n", "found", ":=", "false", "\n\n", "outer_loop", ":", "for", "_", ",", "nested", ":=", "range", "gr", ".", "nested", "{", "// There should be no cycles, but do the check just in case there are,", "// seg faulting with stack overflow is very bad. In case of a cycle, skip", "// the offending group, but keep searching other groups.", "for", "_", ",", "ancestor", ":=", "range", "current", "{", "if", "ancestor", "==", "nested", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "groupName", ")", "\n", "continue", "outer_loop", "\n", "}", "\n", "}", "\n\n", "// Explored 'nested' already (and didn't find anything) while visiting", "// some sibling branch? Skip.", "if", "_", ",", "seen", ":=", "visited", "[", "nested", "]", ";", "seen", "{", "continue", "\n", "}", "\n\n", "if", "isMember", "(", "nested", ")", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "// Note that we don't use defers here since they have non-negligible runtime", "// cost. Using 'defer' here makes IsMember ~1.7x slower (1200 ns vs 700 ns),", "// See BenchmarkIsMember.", "current", "=", "current", "[", ":", "len", "(", "current", ")", "-", "1", "]", "\n", "visited", "[", "gr", "]", "=", "struct", "{", "}", "{", "}", "\n\n", "return", "found", "\n", "}", "\n\n", "if", "gr", ":=", "db", ".", "groups", "[", "groupName", "]", ";", "gr", "!=", "nil", "{", "return", "isMember", "(", "gr", ")", ",", "nil", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "isMemberImpl", "implements", "IsMember", "check", "for", "a", "single", "group", "only", "." ]