Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "getGlobalRand", "(", ")", "(", "*", "Locking", ",", "*", "rand", ".", "Rand", ")", "{", "globalOnce", ".", "Do", "(", "func", "(", ")", "{", "globalRandBase", "=", "newRand", "(", ")", "\n", "globalRand", "=", "&", "Locking", "{", "R", ":", "wrapped", "{", "globalRandBase", "}", "}", "\n", "}", ")", "\n", "return", "globalRand", ",", "globalRandBase", "\n", "}" ]

[ "getGlobalRand", "returns", "globalRand", "and", "its", "Locking", "wrapper", ".", "This", "must", "be", "used", "instead", "of", "direct", "variable", "access", "in", "order", "to", "ensure", "that", "everything", "is", "initialized", ".", "We", "use", "a", "Once", "to", "perform", "this", "initialization", "so", "that", "we", "can", "enable", "applications", "to", "set", "the", "seed", "via", "rand", ".", "Seed", "if", "they", "wish", "." ]

[ "func", "getRand", "(", "c", "context", ".", "Context", ")", "Rand", "{", "if", "r", ",", "ok", ":=", "c", ".", "Value", "(", "&", "key", ")", ".", "(", "Rand", ")", ";", "ok", "{", "return", "r", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "getRand", "returns", "the", "Rand", "installed", "in", "c", "or", "nil", "if", "no", "Rand", "is", "installed", "." ]

[ "func", "readTokenFile", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "(", "*", "tokenserver", ".", "TokenFile", ",", "*", "stateInToken", ")", "{", "blob", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "logging", ".", "Warningf", "(", "ctx", ",", "\"", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n", "return", "&", "tokenserver", ".", "TokenFile", "{", "}", ",", "&", "stateInToken", "{", "}", "\n", "}", "\n", "out", ":=", "&", "tokenserver", ".", "TokenFile", "{", "}", "\n", "if", "err", "=", "jsonpb", ".", "Unmarshal", "(", "bytes", ".", "NewReader", "(", "blob", ")", ",", "out", ")", ";", "err", "!=", "nil", "{", "logging", ".", "Warningf", "(", "ctx", ",", "\"", "\"", ",", "path", ",", "err", ")", "\n", "return", "&", "tokenserver", ".", "TokenFile", "{", "}", ",", "&", "stateInToken", "{", "}", "\n", "}", "\n", "// Attempt to decode stateInToken. Ignore if doesn't work, no big deal.", "state", ":=", "&", "stateInToken", "{", "}", "\n", "if", "err", "=", "json", ".", "Unmarshal", "(", "out", ".", "TokendState", ",", "state", ")", ";", "err", "!=", "nil", "{", "logging", ".", "Warningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "*", "state", "=", "stateInToken", "{", "}", "\n", "}", "\n", "return", "out", ",", "state", "\n", "}" ]

[ "readTokenFile", "reads", "the", "token", "file", "from", "disk", ".", "In", "case", "of", "problems", "logs", "errors", "and", "returns", "default", "structs", "." ]

[ "func", "(", "ld", "*", "logData", ")", "viewerURL", "(", ")", "string", "{", "for", "_", ",", "s", ":=", "range", "ld", ".", "logStreams", "{", "desc", ",", "err", ":=", "s", ".", "DescriptorValue", "(", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "if", "u", ",", "ok", ":=", "desc", ".", "Tags", "[", "\"", "\"", "]", ";", "ok", "{", "return", "u", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "viewerURL", "is", "a", "convenience", "function", "to", "extract", "the", "logdog", ".", "viewer_url", "tag", "out", "of", "a", "logStream", "if", "available", ".", "If", "given", "multiple", "streams", "it", "will", "return", "the", "first", "one", "found", "with", "the", "viewer_url", "tag", "." ]

[ "func", "resolveStreams", "(", "c", "context", ".", "Context", ",", "options", "userOptions", ")", "(", "[", "]", "*", "coordinator", ".", "LogStream", ",", "error", ")", "{", "prefix", ",", "name", ":=", "options", ".", "path", ".", "Split", "(", ")", "\n", "streams", ":=", "[", "]", "*", "coordinator", ".", "LogStream", "{", "}", "\n", "var", "err", "error", "\n", "if", "options", ".", "wildcard", "{", "q", ":=", "datastore", ".", "NewQuery", "(", "\"", "\"", ")", ".", "Eq", "(", "\"", "\"", ",", "prefix", ".", "String", "(", ")", ")", ".", "Eq", "(", "\"", "\"", ",", "false", ")", "\n", "err", "=", "datastore", ".", "GetAll", "(", "c", ",", "q", ",", "&", "streams", ")", "\n", "}", "else", "{", "streams", "=", "append", "(", "streams", ",", "&", "coordinator", ".", "LogStream", "{", "ID", ":", "coordinator", ".", "LogStreamID", "(", "options", ".", "path", ")", "}", ")", "\n", "err", "=", "datastore", ".", "Get", "(", "c", ",", "streams", "[", "0", "]", ")", "\n", "}", "\n\n", "switch", "{", "case", "len", "(", "streams", ")", "==", "0", ",", "datastore", ".", "IsErrNoSuchEntity", "(", "err", ")", ":", "return", "nil", ",", "coordinator", ".", "ErrPathNotFound", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "case", "!", "options", ".", "wildcard", ":", "// If the user requested HTML format, check to see if the stream is a binary or datagram stream.", "// If so, then this mode is not supported, and instead just render a link to the supported mode.", "if", "options", ".", "isHTML", "(", ")", "&&", "streams", "[", "0", "]", ".", "StreamType", "!=", "logpb", ".", "StreamType_TEXT", "{", "err", "=", "errRawRedirect", "\n", "}", "\n", "return", "streams", ",", "err", "\n", "}", "\n\n", "result", ":=", "matchStreams", "(", "streams", ",", "name", ".", "String", "(", ")", ")", "\n", "if", "len", "(", "result", ")", "==", "0", "{", "return", "nil", ",", "coordinator", ".", "ErrPathNotFound", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "resolveStreams", "takes", "a", "path", "containing", "a", "wildcard", "and", "resolves", "it", "to", "the", "list", "of", "all", "known", "paths", ".", "Purge", "checks", "are", "also", "performed", "here", "." ]

[ "func", "initParams", "(", "c", "context", ".", "Context", ",", "streams", "[", "]", "*", "coordinator", ".", "LogStream", ",", "project", "types", ".", "ProjectName", ")", "(", "[", "]", "fetchParams", ",", "error", ")", "{", "states", ":=", "make", "(", "[", "]", "*", "coordinator", ".", "LogStreamState", ",", "len", "(", "streams", ")", ")", "\n", "for", "i", ",", "stream", ":=", "range", "streams", "{", "states", "[", "i", "]", "=", "stream", ".", "State", "(", "c", ")", "\n", "}", "\n", "// Get the log states, which we use to fetch the backend storage.", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "states", ")", ";", "{", "case", "datastore", ".", "IsErrNoSuchEntity", "(", "err", ")", ":", "return", "nil", ",", "coordinator", ".", "ErrPathNotFound", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Get the backend storage instances. These will be closed in fetch.", "params", ":=", "make", "(", "[", "]", "fetchParams", ",", "len", "(", "streams", ")", ")", "\n", "for", "i", ",", "stream", ":=", "range", "streams", "{", "st", ",", "err", ":=", "flex", ".", "GetServices", "(", "c", ")", ".", "StorageForStream", "(", "c", ",", "states", "[", "i", "]", ",", "project", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "params", "[", "i", "]", "=", "fetchParams", "{", "storage", ":", "st", ",", "stream", ":", "stream", ",", "state", ":", "states", "[", "i", "]", ",", "}", "\n", "}", "\n\n", "return", "params", ",", "nil", "\n", "}" ]

[ "initParams", "generates", "a", "set", "of", "params", "for", "each", "LogStream", "given", "." ]

[ "func", "fetch", "(", "c", "context", ".", "Context", ",", "ch", "chan", "<-", "logResp", ",", "allParams", "[", "]", "fetchParams", ")", "{", "defer", "close", "(", "ch", ")", "// Close the channel when we're done fetching.", "\n\n", "// TODO(hinoka): Remove this check once multistream view is supported.", "if", "len", "(", "allParams", ")", ">", "1", "{", "streamPaths", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "allParams", ")", ")", "\n", "for", "i", ",", "p", ":=", "range", "allParams", "{", "streamPaths", "[", "i", "]", "=", "string", "(", "p", ".", "stream", ".", "Path", "(", ")", ")", "\n", "p", ".", "storage", ".", "Close", "(", ")", "\n", "}", "\n", "ch", "<-", "logResp", "{", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "allParams", ")", ",", "strings", ".", "Join", "(", "streamPaths", ",", "\"", "\\n", "\"", ")", ")", "}", "\n", "return", "\n", "}", "\n\n", "// Extract the params we need.", "params", ":=", "allParams", "[", "0", "]", "\n", "state", ":=", "params", ".", "state", "\n", "st", ":=", "params", ".", "storage", "\n", "defer", "st", ".", "Close", "(", ")", "// Close the connection to the backend when we're done.", "\n\n", "index", ":=", "types", ".", "MessageIndex", "(", "0", ")", "\n", "backoff", ":=", "time", ".", "Second", "// How long to wait between fetch requests from storage.", "\n", "var", "err", "error", "\n", "for", "{", "// Get the terminal index from the LogStreamState again if we need to.", "// This is useful when the log stream terminated after the user request started.", "if", "!", "state", ".", "Terminated", "(", ")", "{", "if", "err", "=", "datastore", ".", "Get", "(", "c", ",", "state", ")", ";", "err", "!=", "nil", "{", "ch", "<-", "logResp", "{", "nil", ",", "nil", ",", "err", "}", "\n", "return", "\n", "}", "\n", "}", "\n\n", "// Do the actual work.", "nextIndex", ",", "err", ":=", "fetchOnce", "(", "c", ",", "ch", ",", "index", ",", "params", ")", "\n", "// Signal regardless of error. Server will bail on error and flush otherwise.", "// Important: if fetchOnce errors out, we still expect nextIndex to increment regardless,", "// otherwise this may get stuck in an infinite loop.", "ch", "<-", "logResp", "{", "nil", ",", "nil", ",", "err", "}", "\n\n", "// Check if the log has finished streaming and if we're done.", "if", "state", ".", "Terminated", "(", ")", "&&", "nextIndex", ">", "types", ".", "MessageIndex", "(", "state", ".", "TerminalIndex", ")", "{", "logging", ".", "Fields", "{", "\"", "\"", ":", "state", ".", "TerminalIndex", ",", "\"", "\"", ":", "index", ",", "}", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "index", "=", "nextIndex", "\n", "continue", "\n", "}", "\n\n", "// Log is still streaming. Set the next index, sleep a bit and try again.", "backoff", "=", "backoff", "*", "2", "\n", "if", "backoff", ">", "maxBackoff", "{", "backoff", "=", "maxBackoff", "\n", "}", "\n", "if", "index", "!=", "nextIndex", "{", "if", "err", "!=", "nil", "{", "// An error on one log entry means we want to try the next one asap.", "backoff", "=", "0", "\n", "}", "else", "{", "// If its a relatively active log stream, don't sleep too long.", "backoff", "=", "time", ".", "Second", "\n", "}", "\n", "}", "\n", "if", "tr", ":=", "clock", ".", "Sleep", "(", "c", ",", "backoff", ")", ";", "tr", ".", "Err", "!=", "nil", "{", "// If the user cancelled the request, bail out instead.", "ch", "<-", "logResp", "{", "nil", ",", "nil", ",", "tr", ".", "Err", "}", "\n", "return", "\n", "}", "\n", "index", "=", "nextIndex", "\n", "}", "\n", "}" ]

[ "fetch", "is", "a", "goroutine", "that", "fetches", "log", "entries", "from", "all", "storage", "layers", "and", "sends", "it", "through", "ch", "in", "the", "order", "of", "prefix", "index", ".", "The", "LogStreamState", "is", "used", "purely", "for", "checking", "Terminal", "Indices", "." ]

[ "func", "fetchOnce", "(", "c", "context", ".", "Context", ",", "ch", "chan", "<-", "logResp", ",", "index", "types", ".", "MessageIndex", ",", "params", "fetchParams", ")", "(", "types", ".", "MessageIndex", ",", "error", ")", "{", "// Extract just the parameters we need.", "st", ":=", "params", ".", "storage", "// This is the backend storage instance.", "\n", "archived", ":=", "params", ".", "state", ".", "ArchivalState", "(", ")", ".", "Archived", "(", ")", "\n", "path", ":=", "params", ".", "stream", ".", "Path", "(", ")", "\n\n", "req", ":=", "storage", ".", "GetRequest", "{", "Project", ":", "coordinator", ".", "Project", "(", "c", ")", ",", "Path", ":", "path", ",", "Index", ":", "index", ",", "}", "\n", "var", "ierr", "error", "\n", "// Get as many log entries as we can. The storage layer is responsible for low level retries.", "err", ":=", "st", ".", "Get", "(", "c", ",", "req", ",", "func", "(", "e", "*", "storage", ".", "Entry", ")", "bool", "{", "var", "le", "*", "logpb", ".", "LogEntry", "\n", "if", "le", ",", "ierr", "=", "e", ".", "GetLogEntry", "(", ")", ";", "ierr", "!=", "nil", "{", "// This log entry is bad, just try the next one blindly.", "index", "++", "\n", "return", "false", "\n", "}", "\n", "sidx", ",", "_", ":=", "e", ".", "GetStreamIndex", "(", ")", "// GetLogEntry succeeded, so this must.", "\n", "// Check for a non-continguous stream index. This could mean a couple things:", "// Still streaming: The backend probably needs to catch up. Return false and retry the fetch.", "// Archived: We permanently lost the log entries, just skip over them.", "if", "sidx", "!=", "index", "&&", "!", "archived", "{", "if", "archived", "{", "logging", ".", "Fields", "{", "\"", "\"", ":", "true", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "else", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "// Send the log entry over! This may block if the channel buffer is full.", "ch", "<-", "logResp", "{", "params", ".", "stream", ",", "le", ",", "nil", "}", "\n", "index", "=", "sidx", "+", "1", "\n", "return", "true", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "index", "++", "\n", "logging", ".", "WithError", "(", "err", ")", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "index", ")", "\n", "}", "\n", "// TODO(hinoka): Handle not found case.", "if", "err", "==", "nil", "&&", "ierr", "!=", "nil", "{", "err", "=", "ierr", "\n", "}", "\n", "return", "index", ",", "err", "\n", "}" ]

[ "fetchOnce", "does", "one", "backend", "storage", "request", "for", "logs", "which", "may", "produce", "multiple", "log", "entries", ".", "Log", "entries", "are", "pushed", "into", "ch", ".", "Returns", "the", "next", "stream", "index", "to", "fetch", ".", "It", "is", "possible", "for", "the", "next", "index", "to", "be", "the", "terminal", "index", "+", "1", "so", "the", "calling", "code", "has", "to", "test", "for", "that", "." ]

[ "func", "writeOKHeaders", "(", "ctx", "*", "router", ".", "Context", ",", "data", "logData", ")", "{", "// Tell nginx not to buffer anything.", "ctx", ".", "Writer", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "// Tell the browser to prefer https.", "ctx", ".", "Writer", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "// Set the correct content type based off the log stream and format.", "contentType", ":=", "data", ".", "logStreams", "[", "0", "]", ".", "ContentType", "\n", "if", "data", ".", "options", ".", "isHTML", "(", ")", "{", "// Only text/html is supported for HTML mode.", "contentType", "=", "\"", "\"", "\n", "}", "\n", "ctx", ".", "Writer", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "contentType", ")", "\n", "ctx", ".", "Writer", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "if", "data", ".", "options", ".", "isHTML", "(", ")", "{", "writeHTMLHeader", "(", "ctx", ",", "data", ")", "\n", "}", "\n", "}" ]

[ "writeOKHeaders", "writes", "the", "http", "response", "headers", "in", "accordence", "with", "the", "log", "stream", "type", "and", "user", "options", ".", "The", "error", "is", "passed", "through", "." ]

[ "func", "writeErrorPage", "(", "ctx", "*", "router", ".", "Context", ",", "err", "error", ",", "data", "logData", ")", "{", "ierr", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "switch", "code", ":=", "grpcutil", ".", "Code", "(", "err", ")", ";", "code", "{", "case", "codes", ".", "Unauthenticated", ":", "// Redirect to login screen.", "var", "u", "string", "\n", "u", ",", "ierr", "=", "auth", ".", "LoginURL", "(", "ctx", ".", "Context", ",", "ctx", ".", "Request", ".", "URL", ".", "RequestURI", "(", ")", ")", "\n", "if", "ierr", "==", "nil", "{", "http", ".", "Redirect", "(", "ctx", ".", "Writer", ",", "ctx", ".", "Request", ",", "u", ",", "http", ".", "StatusFound", ")", "\n", "return", "\n", "}", "\n", "logging", ".", "WithError", "(", "ierr", ")", ".", "Errorf", "(", "ctx", ".", "Context", ",", "\"", "\"", ")", "\n", "fallthrough", "\n", "case", "codes", ".", "Internal", ":", "// Hide internal errors, expose all other errors.", "ctx", ".", "Writer", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "default", ":", "ierr", "=", "err", "\n", "ctx", ".", "Writer", ".", "WriteHeader", "(", "grpcutil", ".", "CodeStatus", "(", "code", ")", ")", "\n", "}", "\n", "if", "data", ".", "options", ".", "isHTML", "(", ")", "{", "writeHTMLHeader", "(", "ctx", ",", "data", ")", "\n", "}", "\n", "writeFooter", "(", "ctx", ",", "clock", ".", "Now", "(", "ctx", ".", "Context", ")", ",", "ierr", ",", "data", ".", "options", ".", "isHTML", "(", ")", ")", "\n", "}" ]

[ "writeErrorPage", "renders", "an", "error", "page", "." ]

[ "func", "gradient", "(", "from", ",", "to", "color", ".", "RGBA", ",", "scale", "float64", ")", "(", "result", "color", ".", "RGBA", ")", "{", "scale", "=", "math", ".", "Max", "(", "math", ".", "Min", "(", "scale", ",", "1.0", ")", ",", "0.0", ")", "\n", "result", ".", "R", "=", "linearScale", "(", "from", ".", "R", ",", "to", ".", "R", ",", "scale", ")", "\n", "result", ".", "G", "=", "linearScale", "(", "from", ".", "G", ",", "to", ".", "G", ",", "scale", ")", "\n", "result", ".", "B", "=", "linearScale", "(", "from", ".", "B", ",", "to", ".", "B", ",", "scale", ")", "\n", "return", "\n", "}" ]

[ "gradient", "produces", "a", "color", "between", "from", "and", "to", "colors", "given", "a", "scale", "between", "0", ".", "0", "to", "1", ".", "0", "with", "each", "of", "the", "color", "components", "multiplied", "." ]

[ "func", "serve", "(", "c", "context", ".", "Context", ",", "data", "logData", ",", "w", "http", ".", "ResponseWriter", ")", "(", "err", "error", ")", "{", "// Note: Always put errors in merr instead of returning err.", "// The following defer will drop whatever err is in the named return", "// and replace it with merr.", "// This is done so that all errors can be aggregated.", "merr", ":=", "errors", ".", "MultiError", "{", "}", "\n", "defer", "func", "(", ")", "{", "if", "merr", ".", "First", "(", ")", "==", "nil", "{", "err", "=", "nil", "\n", "}", "else", "{", "err", "=", "merr", "\n", "}", "\n", "}", "(", ")", "\n\n", "flusher", ",", "ok", ":=", "w", ".", "(", "http", ".", "Flusher", ")", "\n", "if", "!", "ok", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ")", "\n", "flusher", "=", "&", "nopFlusher", "{", "}", "\n", "}", "\n", "prevDuration", ":=", "time", ".", "Duration", "(", "0", ")", "\n", "// Serve the logs.", "for", "logResp", ":=", "range", "data", ".", "ch", "{", "log", ",", "ierr", ":=", "logResp", ".", "log", ",", "logResp", ".", "err", "\n", "if", "ierr", "!=", "nil", "{", "merr", "=", "append", "(", "merr", ",", "ierr", ")", "\n", "if", "ierr", ":=", "errorTemplate", ".", "Execute", "(", "w", ",", "ierr", ")", ";", "ierr", "!=", "nil", "{", "merr", "=", "append", "(", "merr", ",", "ierr", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "for", "i", ",", "line", ":=", "range", "log", ".", "GetText", "(", ")", ".", "GetLines", "(", ")", "{", "// For html full mode, we escape and wrap each line with a div.", "// For html lite mode, just escape the line.", "// For raw mode, we just regurgitate the line.", "var", "ierr", "error", "\n", "switch", "data", ".", "options", ".", "format", "{", "case", "formatHTMLFull", ":", "lt", ":=", "logLineStruct", "{", "// Note: We want to use PrefixIndex because we might be viewing more than 1 stream.", "ID", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "log", ".", "PrefixIndex", ",", "i", ")", ",", "// The templating engine below escapes the lines for us.", "Text", ":", "string", "(", "line", ".", "GetValue", "(", ")", ")", ",", "}", "\n", "// Add in timestamp information, if available.", "duration", ",", "perr", ":=", "ptypes", ".", "Duration", "(", "log", ".", "GetTimeOffset", "(", ")", ")", "\n", "if", "perr", "!=", "nil", "{", "logging", ".", "WithError", "(", "perr", ")", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "duration", "=", "prevDuration", "\n", "}", "\n", "lt", ".", "DataTimestamp", "=", "logResp", ".", "stream", ".", "Timestamp", ".", "Add", "(", "duration", ")", ".", "UnixNano", "(", ")", "/", "1e6", "\n", "lt", ".", "DurationInfo", "=", "durationInfo", "(", "prevDuration", ",", "duration", ")", "\n", "prevDuration", "=", "duration", "\n", "ierr", "=", "lineTemplate", ".", "Execute", "(", "w", ",", "lt", ")", "\n", "case", "formatHTMLLite", ":", "text", ":=", "template", ".", "HTMLEscapeString", "(", "string", "(", "line", ".", "GetValue", "(", ")", ")", ")", "\n", "_", ",", "ierr", "=", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "text", ")", "\n", "case", "formatRAW", ":", "_", ",", "ierr", "=", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ",", "line", ".", "GetValue", "(", ")", ",", "line", ".", "GetDelimiter", "(", ")", ")", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "ierr", "!=", "nil", "{", "merr", "=", "append", "(", "merr", ",", "ierr", ")", "\n", "}", "\n", "}", "\n\n", "if", "log", "==", "nil", "{", "// Nil log is a signal that the fetcher completed a cycle of fetches", "// and is sleeping. Flush out all the data in the ResponseWriter so that", "// the user can see it.", "// The go ResponseWriter will not flush until it reaches its threshold.", "flusher", ".", "Flush", "(", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "serve", "reads", "log", "entries", "from", "data", ".", "ch", "and", "writes", "into", "w", "." ]

[ "func", "GetHandler", "(", "ctx", "*", "router", ".", "Context", ")", "{", "start", ":=", "clock", ".", "Now", "(", "ctx", ".", "Context", ")", "\n", "// Start the fetcher and wait for fetched logs to arrive into ch.", "data", ",", "err", ":=", "startFetch", "(", "ctx", ".", "Context", ",", "ctx", ".", "Request", ",", "ctx", ".", "Params", ".", "ByName", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "ctx", ".", "Context", ",", "\"", "\"", ")", "\n", "writeErrorPage", "(", "ctx", ",", "err", ",", "data", ")", "\n", "return", "\n", "}", "\n", "writeOKHeaders", "(", "ctx", ",", "data", ")", "\n\n", "// Write the log contents and then the footer.", "err", "=", "serve", "(", "ctx", ".", "Context", ",", "data", ",", "ctx", ".", "Writer", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "ctx", ".", "Context", ",", "\"", "\"", ")", "\n", "}", "\n", "writeFooter", "(", "ctx", ",", "start", ",", "err", ",", "data", ".", "options", ".", "isHTML", "(", ")", ")", "\n", "}" ]

[ "GetHandler", "is", "an", "HTTP", "handler", "for", "retrieving", "logs", "." ]

[ "func", "(", "p", "*", "parser", ")", "parsePackage", "(", "fileNames", "[", "]", "string", ")", "error", "{", "if", "len", "(", "fileNames", ")", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "i", ",", "name", ":=", "range", "fileNames", "{", "if", "i", ">", "0", "&&", "filepath", ".", "Dir", "(", "name", ")", "!=", "filepath", ".", "Dir", "(", "fileNames", "[", "0", "]", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "name", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "file", ",", "err", ":=", "goparser", ".", "ParseFile", "(", "p", ".", "fileSet", ",", "name", ",", "nil", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "p", ".", "files", ")", ">", "0", "&&", "file", ".", "Name", ".", "Name", "!=", "p", ".", "files", "[", "0", "]", ".", "Name", ".", "Name", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "p", ".", "files", "=", "append", "(", "p", ".", "files", ",", "file", ")", "\n", "}", "\n", "if", "len", "(", "p", ".", "files", ")", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "parsePackage", "parses", ".", "go", "files", "and", "fills", "in", "p", ".", "files", "with", "the", "ASTs", ".", "Files", "must", "be", "in", "the", "same", "directory", "and", "have", "the", "same", "package", "name", "." ]

[ "func", "(", "p", "*", "parser", ")", "recordImport", "(", "f", "*", "ast", ".", "File", ",", "typ", "ast", ".", "Expr", ")", "error", "{", "if", "star", ",", "ok", ":=", "typ", ".", "(", "*", "ast", ".", "StarExpr", ")", ";", "ok", "{", "typ", "=", "star", ".", "X", "\n", "}", "\n\n", "sel", ",", "ok", ":=", "typ", ".", "(", "*", "ast", ".", "SelectorExpr", ")", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "pkgID", ",", "ok", ":=", "sel", ".", "X", ".", "(", "*", "ast", ".", "Ident", ")", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "p", ".", "extraImports", "[", "pkgID", ".", "Name", "]", ";", "ok", "{", "return", "nil", "\n", "}", "\n\n", "path", ":=", "\"", "\"", "\n", "for", "_", ",", "i", ":=", "range", "f", ".", "Imports", "{", "if", "i", ".", "Name", ".", "Name", "==", "pkgID", ".", "Name", "{", "path", "=", "strings", ".", "Trim", "(", "i", ".", "Path", ".", "Value", ",", "`\"`", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "path", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pkgID", ".", "Name", ")", "\n", "}", "\n", "if", "p", ".", "extraImports", "==", "nil", "{", "p", ".", "extraImports", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "p", ".", "extraImports", "[", "pkgID", ".", "Name", "]", "=", "path", "\n", "return", "nil", "\n", "}" ]

[ "recordImport", "extracts", "the", "package", "referenced", "by", "type", "expression", "typ", "resolves", "its", "path", "and", "saves", "to", "p", ".", "extraImports", "." ]

[ "func", "(", "p", "*", "parser", ")", "exprString", "(", "expr", "ast", ".", "Expr", ")", "(", "string", ",", "error", ")", "{", "p", ".", "exprStrBuf", ".", "Reset", "(", ")", "\n", "err", ":=", "printer", ".", "Fprint", "(", "&", "p", ".", "exprStrBuf", ",", "p", ".", "fileSet", ",", "expr", ")", "\n", "return", "p", ".", "exprStrBuf", ".", "String", "(", ")", ",", "err", "\n", "}" ]

[ "exprString", "renders", "expr", "to", "string", "." ]

[ "func", "ResetExecutionTimeout", "(", "c", "context", ".", "Context", ",", "e", "*", "model", ".", "Execution", ")", "error", "{", "howLong", ":=", "time", ".", "Duration", "(", "0", ")", "\n", "switch", "e", ".", "State", "{", "case", "dm", ".", "Execution_SCHEDULING", ":", "howLong", "=", "e", ".", "TimeToStart", "\n", "case", "dm", ".", "Execution_RUNNING", ":", "howLong", "=", "e", ".", "TimeToRun", "\n", "case", "dm", ".", "Execution_STOPPING", ":", "howLong", "=", "e", ".", "TimeToStop", "\n", "}", "\n", "eid", ":=", "e", ".", "GetEID", "(", ")", "\n", "key", ":=", "model", ".", "ExecutionKeyFromID", "(", "c", ",", "eid", ")", "\n", "if", "howLong", "==", "0", "{", "return", "tumble", ".", "CancelNamedMutations", "(", "c", ",", "key", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "tumble", ".", "PutNamedMutations", "(", "c", ",", "key", ",", "map", "[", "string", "]", "tumble", ".", "Mutation", "{", "\"", "\"", ":", "&", "TimeoutExecution", "{", "eid", ",", "e", ".", "State", ",", "0", ",", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", ".", "Add", "(", "howLong", ")", "}", ",", "}", ")", "\n", "}" ]

[ "ResetExecutionTimeout", "schedules", "a", "Timeout", "for", "this", "Execution", ".", "It", "inspects", "the", "Execution", "s", "State", "to", "determine", "which", "timeout", "should", "be", "set", "if", "any", ".", "If", "no", "timeout", "should", "be", "active", "this", "will", "cancel", "any", "existing", "timeouts", "for", "this", "Execution", "." ]

[ "func", "Cmd", "(", "params", "base", ".", "Parameters", ")", "*", "subcommands", ".", "Command", "{", "return", "&", "subcommands", ".", "Command", "{", "UsageLine", ":", "\"", "\"", ",", "ShortDesc", ":", "\"", "\"", ",", "LongDesc", ":", "`Interprets a high-level config, generating *.cfg files.\n\nWrites generated configs to the directory given via -config-dir or via\nlucicfg.config(config_dir=...) statement in the script. If it is '-', just\nprints them to stdout.\n\nIf -validate is given, sends the generated config to LUCI Config service for\nvalidation. This can also be done separately via 'validate' subcommand.\n\nIf the generation stage fails, doesn't overwrite any files on disk. If the\ngeneration succeeds, but the validation fails, the new generated files are kept\non disk, so they can be manually examined for reasons they are invalid.\n`", ",", "CommandRun", ":", "func", "(", ")", "subcommands", ".", "CommandRun", "{", "gr", ":=", "&", "generateRun", "{", "}", "\n", "gr", ".", "Init", "(", "params", ")", "\n", "gr", ".", "AddMetaFlags", "(", ")", "\n", "gr", ".", "Flags", ".", "BoolVar", "(", "&", "gr", ".", "validate", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "return", "gr", "\n", "}", ",", "}", "\n", "}" ]

[ "Cmd", "is", "generate", "subcommand", "." ]

[ "func", "(", "s", "*", "server", ")", "Get", "(", "c", "context", ".", "Context", ",", "req", "*", "logdog", ".", "GetRequest", ")", "(", "*", "logdog", ".", "GetResponse", ",", "error", ")", "{", "return", "s", ".", "getImpl", "(", "c", ",", "req", ",", "false", ")", "\n", "}" ]

[ "Get", "returns", "state", "and", "log", "data", "for", "a", "single", "log", "stream", "." ]

[ "func", "(", "s", "*", "server", ")", "Tail", "(", "c", "context", ".", "Context", ",", "req", "*", "logdog", ".", "TailRequest", ")", "(", "*", "logdog", ".", "GetResponse", ",", "error", ")", "{", "r", ":=", "logdog", ".", "GetRequest", "{", "Project", ":", "req", ".", "Project", ",", "Path", ":", "req", ".", "Path", ",", "State", ":", "req", ".", "State", ",", "}", "\n", "return", "s", ".", "getImpl", "(", "c", ",", "&", "r", ",", "true", ")", "\n", "}" ]

[ "Tail", "returns", "the", "last", "log", "entry", "for", "a", "given", "log", "stream", "." ]

[ "func", "(", "s", "*", "server", ")", "getImpl", "(", "c", "context", ".", "Context", ",", "req", "*", "logdog", ".", "GetRequest", ",", "tail", "bool", ")", "(", "*", "logdog", ".", "GetResponse", ",", "error", ")", "{", "log", ".", "Fields", "{", "\"", "\"", ":", "req", ".", "Project", ",", "\"", "\"", ":", "req", ".", "Path", ",", "\"", "\"", ":", "req", ".", "Index", ",", "\"", "\"", ":", "tail", ",", "}", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n\n", "path", ":=", "types", ".", "StreamPath", "(", "req", ".", "Path", ")", "\n", "if", "err", ":=", "path", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Errf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n\n", "ls", ":=", "&", "coordinator", ".", "LogStream", "{", "ID", ":", "coordinator", ".", "LogStreamID", "(", "path", ")", "}", "\n", "lst", ":=", "ls", ".", "State", "(", "c", ")", "\n", "log", ".", "Fields", "{", "\"", "\"", ":", "ls", ".", "ID", ",", "}", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n\n", "if", "err", ":=", "ds", ".", "Get", "(", "c", ",", "ls", ",", "lst", ")", ";", "err", "!=", "nil", "{", "if", "ds", ".", "IsErrNoSuchEntity", "(", "err", ")", "{", "log", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Errf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ")", "\n", "}", "\n\n", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Internal", "\n", "}", "\n\n", "// If this log entry is Purged and we're not admin, pretend it doesn't exist.", "if", "ls", ".", "Purged", "{", "if", "authErr", ":=", "coordinator", ".", "IsAdminUser", "(", "c", ")", ";", "authErr", "!=", "nil", "{", "log", ".", "Fields", "{", "log", ".", "ErrorKey", ":", "authErr", ",", "}", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Errf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "resp", ":=", "logdog", ".", "GetResponse", "{", "}", "\n", "if", "req", ".", "State", "{", "resp", ".", "State", "=", "buildLogStreamState", "(", "ls", ",", "lst", ")", "\n\n", "var", "err", "error", "\n", "resp", ".", "Desc", ",", "err", "=", "ls", ".", "DescriptorValue", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Internal", "\n", "}", "\n", "}", "\n\n", "// Retrieve requested logs from storage, if requested.", "startTime", ":=", "clock", ".", "Now", "(", "c", ")", "\n", "if", "err", ":=", "s", ".", "getLogs", "(", "c", ",", "req", ",", "&", "resp", ",", "tail", ",", "ls", ",", "lst", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Internal", "\n", "}", "\n\n", "log", ".", "Fields", "{", "\"", "\"", ":", "clock", ".", "Now", "(", "c", ")", ".", "Sub", "(", "startTime", ")", ".", "String", "(", ")", ",", "\"", "\"", ":", "len", "(", "resp", ".", "Logs", ")", ",", "}", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "&", "resp", ",", "nil", "\n", "}" ]

[ "getImpl", "is", "common", "code", "shared", "between", "Get", "and", "Tail", "endpoints", "." ]

[ "func", "(", "l", "*", "buildListener", ")", "StreamRegistrationCallback", "(", "desc", "*", "logpb", ".", "LogStreamDescriptor", ")", "bundler", ".", "StreamChunkCallback", "{", "if", "desc", ".", "Name", "==", "l", ".", "buildStreamName", "{", "switch", "{", "case", "desc", ".", "ContentType", "!=", "protoutil", ".", "BuildMediaType", ":", "l", ".", "report", "(", "errors", ".", "Reason", "(", "\"", "\"", ",", "desc", ".", "Name", ",", "desc", ".", "ContentType", ",", "protoutil", ".", "BuildMediaType", ")", ".", "Err", "(", ")", ")", "\n", "case", "desc", ".", "StreamType", "!=", "logpb", ".", "StreamType_DATAGRAM", ":", "l", ".", "report", "(", "errors", ".", "Reason", "(", "\"", "\"", ",", "desc", ".", "Name", ",", "desc", ".", "StreamType", ",", "logpb", ".", "StreamType_DATAGRAM", ")", ".", "Err", "(", ")", ")", "\n", "default", ":", "return", "buffered_callback", ".", "GetWrappedDatagramCallback", "(", "l", ".", "onBuildChunk", ")", "\n", "}", "\n", "}", "\n\n", "// TODO(nodir): add support for sub-builds.", "return", "nil", "\n", "}" ]

[ "StreamRegistrationCallback", "can", "be", "used", "as", "logdogServer", ".", "StreamRegistrationCallback", "." ]

[ "func", "(", "l", "*", "buildListener", ")", "Build", "(", ")", "*", "pb", ".", "Build", "{", "l", ".", "buildMU", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "buildMU", ".", "Unlock", "(", ")", "\n\n", "if", "l", ".", "build", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "proto", ".", "Clone", "(", "l", ".", "build", ")", ".", "(", "*", "pb", ".", "Build", ")", "\n", "}" ]

[ "Build", "returns", "most", "recently", "retrieved", "Build", "message", "." ]

[ "func", "(", "l", "*", "buildListener", ")", "report", "(", "err", "error", ")", "{", "l", ".", "onErr", "(", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", ")", "\n", "}" ]

[ "report", "reports", "a", "LUCI", "executable", "protocol", "violation", "via", "l", ".", "onErr", "." ]

[ "func", "NewBuilderID", "(", "v1Bucket", ",", "builder", "string", ")", "(", "bid", "BuilderID", ")", "{", "bid", ".", "Project", ",", "bid", ".", "Bucket", "=", "deprecated", ".", "BucketNameToV2", "(", "v1Bucket", ")", "\n", "bid", ".", "Builder", "=", "builder", "\n", "return", "\n", "}" ]

[ "NewBuilderID", "does", "what", "it", "says", "." ]

[ "func", "(", "b", "BuilderID", ")", "V1Bucket", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Project", ",", "b", ".", "Bucket", ")", "\n", "}" ]

[ "V1Bucket", "returns", "the", "buildbucket", "v1", "representation", "of", "the", "bucket", "name", "which", "is", "what", "we", "use", "in", "Milo", "." ]

[ "func", "(", "b", "BuilderID", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "V1Bucket", "(", ")", ",", "b", ".", "Builder", ")", "\n", "}" ]

[ "String", "returns", "the", "canonical", "format", "of", "BuilderID", "." ]

[ "func", "fetchBuilds", "(", "c", "context", ".", "Context", ",", "client", "*", "bbv1", ".", "Service", ",", "bid", "BuilderID", ",", "status", "string", ",", "limit", "int", ",", "cursor", "string", ")", "(", "[", "]", "*", "bbv1", ".", "ApiCommonBuildMessage", ",", "string", ",", "error", ")", "{", "c", ",", "_", "=", "context", ".", "WithTimeout", "(", "c", ",", "bbRPCTimeout", ")", "\n", "search", ":=", "client", ".", "Search", "(", ")", "\n", "search", ".", "Context", "(", "c", ")", "\n", "search", ".", "Bucket", "(", "bid", ".", "V1Bucket", "(", ")", ")", "\n", "search", ".", "Status", "(", "status", ")", "\n", "search", ".", "Tag", "(", "strpair", ".", "Format", "(", "bbv1", ".", "TagBuilder", ",", "bid", ".", "Builder", ")", ")", "\n", "search", ".", "IncludeExperimental", "(", "true", ")", "\n", "search", ".", "StartCursor", "(", "cursor", ")", "\n\n", "if", "limit", "<", "0", "{", "limit", "=", "100", "\n", "}", "\n\n", "start", ":=", "clock", ".", "Now", "(", "c", ")", "\n", "msgs", ",", "cursor", ",", "err", ":=", "search", ".", "Fetch", "(", "limit", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "len", "(", "msgs", ")", ",", "status", ",", "clock", ".", "Since", "(", "c", ",", "start", ")", ")", "\n", "return", "msgs", ",", "cursor", ",", "nil", "\n", "}" ]

[ "fetchBuilds", "fetches", "builds", "given", "a", "criteria", ".", "The", "returned", "builds", "are", "sorted", "by", "build", "creation", "descending", ".", "count", "defines", "maximum", "number", "of", "builds", "to", "fetch", ";", "if", "<0", "defaults", "to", "100", "." ]

[ "func", "ensureDefined", "(", "c", "context", ".", "Context", ",", "host", "string", ",", "bid", "BuilderID", ")", "error", "{", "client", ",", "err", ":=", "newSwarmbucketClient", "(", "c", ",", "host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "getBuilders", ":=", "client", ".", "GetBuilders", "(", ")", "\n", "getBuilders", ".", "Bucket", "(", "bid", ".", "V1Bucket", "(", ")", ")", "\n", "getBuilders", ".", "Fields", "(", "googleapi", ".", "Field", "(", "\"", "\"", ")", ")", "\n", "res", ",", "err", ":=", "getBuilders", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "bucket", ":=", "range", "res", ".", "Buckets", "{", "if", "bucket", ".", "Name", "!=", "bid", ".", "V1Bucket", "(", ")", "{", "continue", "// defensive programming; shouldn't happen in practice.", "\n", "}", "\n", "for", "_", ",", "builder", ":=", "range", "bucket", ".", "Builders", "{", "if", "builder", ".", "Name", "==", "bid", ".", "Builder", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "bid", ".", "Builder", ")", ".", "Tag", "(", "grpcutil", ".", "NotFoundTag", ")", ".", "Err", "(", ")", "\n", "}" ]

[ "ensureDefined", "returns", "grpcutil", ".", "NotFoundTag", "tagged", "error", "if", "a", "builder", "is", "not", "defined", "in", "its", "swarmbucket", "." ]

[ "func", "backCursor", "(", "c", "context", ".", "Context", ",", "bid", "BuilderID", ",", "limit", "int", ",", "thisCursor", ",", "nextCursor", "string", ")", "string", "{", "memcacheKey", ":=", "func", "(", "cursor", "string", ")", "string", "{", "key", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "bid", ".", "String", "(", ")", ",", "limit", ",", "cursor", ")", "\n", "blob", ":=", "sha1", ".", "Sum", "(", "[", "]", "byte", "(", "key", ")", ")", "\n", "encoded", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "blob", "[", ":", "]", ")", "\n", "return", "\"", "\"", "+", "encoded", "\n", "}", "\n\n", "prevCursor", ":=", "\"", "\"", "\n", "if", "thisCursor", "!=", "\"", "\"", "{", "if", "item", ",", "err", ":=", "memcache", ".", "GetKey", "(", "c", ",", "memcacheKey", "(", "thisCursor", ")", ")", ";", "err", "==", "nil", "{", "prevCursor", "=", "string", "(", "item", ".", "Value", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "nextCursor", "!=", "\"", "\"", "{", "item", ":=", "memcache", ".", "NewItem", "(", "c", ",", "memcacheKey", "(", "nextCursor", ")", ")", "\n", "if", "thisCursor", "==", "\"", "\"", "{", "item", ".", "SetValue", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "}", "else", "{", "item", ".", "SetValue", "(", "[", "]", "byte", "(", "thisCursor", ")", ")", "\n", "}", "\n", "item", ".", "SetExpiration", "(", "24", "*", "time", ".", "Hour", ")", "\n", "memcache", ".", "Set", "(", "c", ",", "item", ")", "\n", "}", "\n", "return", "prevCursor", "\n", "}" ]

[ "backCursor", "implements", "bidirectional", "cursors", "with", "forward", "-", "only", "datastore", "cursors", "by", "storing", "a", "map", "for", "cursor", "-", ">", "prevCursor", "in", "memcache", ".", "backCursor", "returns", "a", "previous", "cursor", "given", "thisCursor", "and", "caches", "thisCursor", "to", "be", "the", "previous", "cursor", "of", "nextCursor", "." ]

[ "func", "toMiloBuildsSummaries", "(", "c", "context", ".", "Context", ",", "msgs", "[", "]", "*", "bbv1", ".", "ApiCommonBuildMessage", ")", "[", "]", "*", "ui", ".", "BuildSummary", "{", "result", ":=", "make", "(", "[", "]", "*", "ui", ".", "BuildSummary", ",", "len", "(", "msgs", ")", ")", "\n", "// For each build, toMiloBuild may query Gerrit to fetch associated CL's", "// author email. Unfortunately, as of June 2018 Gerrit is often taking >5s to", "// report back. From UX PoV, author's email isn't the most important of", "// builder's page, so limit waiting time.", "c", ",", "_", "=", "context", ".", "WithTimeout", "(", "c", ",", "5", "*", "time", ".", "Second", ")", "\n", "// This does not error.", "parallel", ".", "WorkPool", "(", "50", ",", "func", "(", "work", "chan", "<-", "func", "(", ")", "error", ")", "{", "for", "i", ",", "m", ":=", "range", "msgs", "{", "i", ":=", "i", "\n", "m", ":=", "m", "\n", "work", "<-", "func", "(", ")", "error", "{", "// HACK(hinoka): For malformed builds (eg builder name and builder name tag don't match)", "// We can drop them silently or display an error. We choose the latter.", "// Once we switch to the V2 we should be more resilient to these classes of issues.", "mb", ",", "err", ":=", "ToMiloBuild", "(", "c", ",", "m", ",", "false", ")", "\n", "if", "err", "==", "nil", "{", "result", "[", "i", "]", "=", "mb", ".", "BuildSummary", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "m", ".", "Id", ",", "err", ")", "\n", "logging", ".", "Errorf", "(", "c", ",", "msg", ")", "\n", "result", "[", "i", "]", "=", "&", "ui", ".", "BuildSummary", "{", "Link", ":", "ui", ".", "NewEmptyLink", "(", "\"", "\"", ")", ",", "Status", ":", "model", ".", "InfraFailure", ",", "Text", ":", "[", "]", "string", "{", "msg", "}", ",", "}", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}", ")", "\n", "return", "result", "\n", "}" ]

[ "toMiloBuildsSummaries", "computes", "summary", "for", "each", "build", "in", "parallel", "." ]

[ "func", "GetBuilder", "(", "c", "context", ".", "Context", ",", "bid", "BuilderID", ",", "limit", "int", ",", "cursor", "string", ")", "(", "*", "ui", ".", "Builder", ",", "error", ")", "{", "host", ",", "err", ":=", "getHost", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "limit", "<", "0", "{", "limit", "=", "20", "\n", "}", "\n\n", "result", ":=", "&", "ui", ".", "Builder", "{", "Name", ":", "bid", ".", "Builder", ",", "}", "\n", "if", "host", "==", "\"", "\"", "{", "return", "result", ",", "getDebugBuilds", "(", "c", ",", "bid", ",", "limit", ",", "result", ")", "\n", "}", "\n", "client", ",", "err", ":=", "newBuildbucketClient", "(", "c", ",", "host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "fetch", ":=", "func", "(", "statusFilter", "string", ",", "limit", "int", ",", "cursor", "string", ")", "(", "result", "[", "]", "*", "ui", ".", "BuildSummary", ",", "nextCursor", "string", ",", "err", "error", ")", "{", "msgs", ",", "nextCursor", ",", "err", ":=", "fetchBuilds", "(", "c", ",", "client", ",", "bid", ",", "statusFilter", ",", "limit", ",", "cursor", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "statusFilter", ")", "\n", "return", "\n", "}", "\n", "result", "=", "toMiloBuildsSummaries", "(", "c", ",", "msgs", ")", "\n", "return", "\n", "}", "\n", "return", "result", ",", "parallel", ".", "FanOutIn", "(", "func", "(", "work", "chan", "<-", "func", "(", ")", "error", ")", "{", "work", "<-", "func", "(", ")", "error", "{", "return", "ensureDefined", "(", "c", ",", "host", ",", "bid", ")", "\n", "}", "\n", "work", "<-", "func", "(", ")", "(", "err", "error", ")", "{", "result", ".", "MachinePool", ",", "err", "=", "getPool", "(", "c", ",", "bid", ")", "\n", "return", "\n", "}", "\n", "work", "<-", "func", "(", ")", "(", "err", "error", ")", "{", "result", ".", "PendingBuilds", ",", "_", ",", "err", "=", "fetch", "(", "bbv1", ".", "StatusScheduled", ",", "-", "1", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "work", "<-", "func", "(", ")", "(", "err", "error", ")", "{", "result", ".", "CurrentBuilds", ",", "_", ",", "err", "=", "fetch", "(", "bbv1", ".", "StatusStarted", ",", "-", "1", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "work", "<-", "func", "(", ")", "(", "err", "error", ")", "{", "result", ".", "FinishedBuilds", ",", "result", ".", "NextCursor", ",", "err", "=", "fetch", "(", "bbv1", ".", "StatusCompleted", ",", "limit", ",", "cursor", ")", "\n", "result", ".", "PrevCursor", "=", "backCursor", "(", "c", ",", "bid", ",", "limit", ",", "cursor", ",", "result", ".", "NextCursor", ")", "// Safe to do even with error.", "\n", "return", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "GetBuilder", "is", "used", "by", "buildsource", ".", "BuilderID", ".", "Get", "to", "obtain", "the", "resp", ".", "Builder", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "Validate", "(", "c", "*", "validation", ".", "Context", ")", "{", "c", ".", "Enter", "(", "\"", "\"", ")", "\n", "cfg", ".", "GetAmount", "(", ")", ".", "Validate", "(", "c", ")", "\n", "c", ".", "Exit", "(", ")", "\n", "c", ".", "Enter", "(", "\"", "\"", ")", "\n", "cfg", ".", "GetAttributes", "(", ")", ".", "Validate", "(", "c", ")", "\n", "c", ".", "Exit", "(", ")", "\n", "c", ".", "Enter", "(", "\"", "\"", ")", "\n", "cfg", ".", "GetLifetime", "(", ")", ".", "Validate", "(", "c", ")", "\n", "switch", "n", ",", "err", ":=", "cfg", ".", "Lifetime", ".", "ToSeconds", "(", ")", ";", "{", "case", "err", "!=", "nil", ":", "c", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "case", "n", "==", "0", ":", "c", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "c", ".", "Exit", "(", ")", "\n", "if", "cfg", ".", "GetPrefix", "(", ")", "==", "\"", "\"", "{", "c", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "GetRevision", "(", ")", "!=", "\"", "\"", "{", "c", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "c", ".", "Enter", "(", "\"", "\"", ")", "\n", "cfg", ".", "GetTimeout", "(", ")", ".", "Validate", "(", "c", ")", "\n", "c", ".", "Exit", "(", ")", "\n", "}" ]

[ "Validate", "validates", "this", "config", ".", "Kind", "must", "already", "be", "applied", "." ]

[ "func", "(", "m", "*", "OAuth2Method", ")", "GetUserCredentials", "(", "c", "context", ".", "Context", ",", "r", "*", "http", ".", "Request", ")", "(", "*", "oauth2", ".", "Token", ",", "error", ")", "{", "chunks", ":=", "strings", ".", "SplitN", "(", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "||", "(", "chunks", "[", "0", "]", "!=", "\"", "\"", "&&", "chunks", "[", "0", "]", "!=", "\"", "\"", ")", "{", "return", "nil", ",", "errBadAuthHeader", "\n", "}", "\n", "return", "&", "oauth2", ".", "Token", "{", "AccessToken", ":", "chunks", "[", "1", "]", ",", "TokenType", ":", "\"", "\"", ",", "}", ",", "nil", "\n", "}" ]

[ "GetUserCredentials", "implements", "auth", ".", "UserCredentialsGetter", "." ]

[ "func", "(", "s", "*", "BaseStream", ")", "WriteDatagram", "(", "dg", "[", "]", "byte", ")", "error", "{", "if", "!", "s", ".", "isDatagramStream", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "s", ".", "writeRecord", "(", "dg", ")", "\n", "}" ]

[ "WriteDatagram", "implements", "StreamClient", "." ]

[ "func", "(", "s", "*", "BaseStream", ")", "Write", "(", "data", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "if", "s", ".", "isDatagramStream", "(", ")", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "s", ".", "writeRaw", "(", "data", ")", "\n", "}" ]

[ "Write", "implements", "StreamClient", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Debugf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "m", ".", "LogCall", "(", "logging", ".", "Debug", ",", "1", ",", "format", ",", "args", ")", "\n", "}" ]

[ "Debugf", "implements", "the", "logging", ".", "Logger", "interface", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Infof", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "m", ".", "LogCall", "(", "logging", ".", "Info", ",", "1", ",", "format", ",", "args", ")", "\n", "}" ]

[ "Infof", "implements", "the", "logging", ".", "Logger", "interface", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Warningf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "m", ".", "LogCall", "(", "logging", ".", "Warning", ",", "1", ",", "format", ",", "args", ")", "\n", "}" ]

[ "Warningf", "implements", "the", "logging", ".", "Logger", "interface", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Errorf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "m", ".", "LogCall", "(", "logging", ".", "Error", ",", "1", ",", "format", ",", "args", ")", "\n", "}" ]

[ "Errorf", "implements", "the", "logging", ".", "Logger", "interface", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "LogCall", "(", "lvl", "logging", ".", "Level", ",", "calldepth", "int", ",", "format", "string", ",", "args", "[", "]", "interface", "{", "}", ")", "{", "if", "m", ".", "lock", "!=", "nil", "{", "m", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "lock", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "m", ".", "data", "==", "nil", "{", "m", ".", "data", "=", "new", "(", "[", "]", "LogEntry", ")", "\n", "}", "\n", "*", "m", ".", "data", "=", "append", "(", "*", "m", ".", "data", ",", "LogEntry", "{", "lvl", ",", "fmt", ".", "Sprintf", "(", "format", ",", "args", "...", ")", ",", "m", ".", "fields", ",", "calldepth", "+", "1", "}", ")", "\n", "}" ]

[ "LogCall", "implements", "the", "logging", ".", "Logger", "interface", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Messages", "(", ")", "[", "]", "LogEntry", "{", "if", "m", ".", "lock", "!=", "nil", "{", "m", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "lock", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "m", ".", "data", "==", "nil", "||", "len", "(", "*", "m", ".", "data", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "ret", ":=", "make", "(", "[", "]", "LogEntry", ",", "len", "(", "*", "m", ".", "data", ")", ")", "\n", "copy", "(", "ret", ",", "*", "m", ".", "data", ")", "\n", "return", "ret", "\n", "}" ]

[ "Messages", "returns", "all", "of", "the", "log", "messages", "that", "this", "memory", "logger", "has", "recorded", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Reset", "(", ")", "{", "if", "m", ".", "lock", "!=", "nil", "{", "m", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "lock", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "m", ".", "data", "!=", "nil", "{", "*", "m", ".", "data", "=", "nil", "\n", "}", "\n", "}" ]

[ "Reset", "resets", "the", "logged", "messages", "recorded", "so", "far", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "GetFunc", "(", "f", "func", "(", "*", "LogEntry", ")", "bool", ")", "*", "LogEntry", "{", "if", "m", ".", "lock", "!=", "nil", "{", "m", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "lock", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "m", ".", "data", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "for", "_", ",", "ent", ":=", "range", "*", "m", ".", "data", "{", "if", "f", "(", "&", "ent", ")", "{", "clone", ":=", "ent", "\n", "return", "&", "clone", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetFunc", "returns", "the", "first", "matching", "log", "entry", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Get", "(", "lvl", "logging", ".", "Level", ",", "msg", "string", ",", "data", "map", "[", "string", "]", "interface", "{", "}", ")", "*", "LogEntry", "{", "return", "m", ".", "GetFunc", "(", "func", "(", "ent", "*", "LogEntry", ")", "bool", "{", "return", "ent", ".", "Level", "==", "lvl", "&&", "ent", ".", "Msg", "==", "msg", "&&", "reflect", ".", "DeepEqual", "(", "data", ",", "ent", ".", "Data", ")", "\n", "}", ")", "\n", "}" ]

[ "Get", "returns", "the", "first", "matching", "log", "entry", ".", "Note", "that", "lvl", "msg", "and", "data", "have", "to", "match", "the", "entry", "precisely", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "HasFunc", "(", "f", "func", "(", "*", "LogEntry", ")", "bool", ")", "bool", "{", "return", "m", ".", "GetFunc", "(", "f", ")", "!=", "nil", "\n", "}" ]

[ "HasFunc", "returns", "true", "iff", "the", "MemLogger", "contains", "a", "matching", "log", "message", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Has", "(", "lvl", "logging", ".", "Level", ",", "msg", "string", ",", "data", "map", "[", "string", "]", "interface", "{", "}", ")", "bool", "{", "return", "m", ".", "Get", "(", "lvl", ",", "msg", ",", "data", ")", "!=", "nil", "\n", "}" ]

[ "Has", "returns", "true", "iff", "the", "MemLogger", "contains", "the", "specified", "log", "message", ".", "Note", "that", "lvl", "msg", "and", "data", "have", "to", "match", "the", "entry", "precisely", "." ]

[ "func", "(", "m", "*", "MemLogger", ")", "Dump", "(", "w", "io", ".", "Writer", ")", "(", "n", "int", ",", "err", "error", ")", "{", "amt", ":=", "0", "\n", "for", "i", ",", "msg", ":=", "range", "m", ".", "Messages", "(", ")", "{", "if", "i", "==", "0", "{", "amt", ",", "err", "=", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\\n", "\"", ")", "\n", "n", "+=", "amt", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "if", "msg", ".", "Data", "==", "nil", "{", "amt", ",", "err", "=", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "msg", ".", "Level", ",", "msg", ".", "Msg", ")", "\n", "n", "+=", "amt", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "else", "{", "amt", ",", "err", "=", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "msg", ".", "Level", ",", "msg", ".", "Msg", ",", "logging", ".", "Fields", "(", "msg", ".", "Data", ")", ")", "\n", "n", "+=", "amt", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Dump", "dumps", "the", "current", "memory", "logger", "contents", "to", "the", "given", "writer", "in", "a", "human", "-", "readable", "format", "." ]

[ "func", "Dump", "(", "c", "context", ".", "Context", ",", "w", "io", ".", "Writer", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "logging", ".", "Get", "(", "c", ")", ".", "(", "*", "MemLogger", ")", ".", "Dump", "(", "w", ")", "\n", "}" ]

[ "Dump", "is", "a", "convenience", "function", "to", "dump", "the", "current", "contents", "of", "the", "memory", "logger", "to", "the", "writer", ".", "This", "will", "panic", "if", "the", "current", "logger", "is", "not", "a", "memory", "logger", "." ]

[ "func", "MustDumpStdout", "(", "c", "context", ".", "Context", ")", "{", "_", ",", "err", ":=", "logging", ".", "Get", "(", "c", ")", ".", "(", "*", "MemLogger", ")", ".", "Dump", "(", "os", ".", "Stdout", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "MustDumpStdout", "is", "a", "convenience", "function", "to", "dump", "the", "current", "contents", "of", "the", "memory", "logger", "to", "stdout", ".", "This", "will", "panic", "if", "the", "current", "logger", "is", "not", "a", "memory", "logger", "." ]

[ "func", "(", "WindowsStrategy", ")", "configureAutoMount", "(", "ctx", "context", ".", "Context", ",", "disk", "string", ")", "error", "{", "// TODO(smut): Mount the specified disk.", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

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

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

[ "getAgent", "returns", "an", "agent", "which", "runs", "on", "Windows", "." ]

[ "func", "NewUserAuthTokenProvider", "(", "ctx", "context", ".", "Context", ",", "clientID", ",", "clientSecret", "string", ",", "scopes", "[", "]", "string", ")", "(", "TokenProvider", ",", "error", ")", "{", "return", "&", "userAuthTokenProvider", "{", "config", ":", "&", "oauth2", ".", "Config", "{", "ClientID", ":", "clientID", ",", "ClientSecret", ":", "clientSecret", ",", "Endpoint", ":", "oauth2", ".", "Endpoint", "{", "AuthURL", ":", "\"", "\"", ",", "TokenURL", ":", "\"", "\"", ",", "}", ",", "RedirectURL", ":", "\"", "\"", ",", "Scopes", ":", "scopes", ",", "}", ",", "cacheKey", ":", "CacheKey", "{", "Key", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "clientID", ")", ",", "Scopes", ":", "scopes", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "NewUserAuthTokenProvider", "returns", "TokenProvider", "that", "can", "perform", "3", "-", "legged", "OAuth", "flow", "involving", "interaction", "with", "a", "user", "." ]

[ "func", "WithServices", "(", "c", "context", ".", "Context", ",", "s", "Services", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "&", "servicesKey", ",", "s", ")", "\n", "}" ]

[ "WithServices", "installs", "the", "supplied", "Services", "instance", "into", "a", "Context", "." ]

[ "func", "(", "td", "*", "TempDir", ")", "With", "(", "fn", "func", "(", "string", ")", "error", ")", "error", "{", "tdir", ",", "err", ":=", "ioutil", ".", "TempDir", "(", "td", ".", "Dir", ",", "td", ".", "Prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "rmErr", ":=", "RemoveAll", "(", "tdir", ")", ";", "rmErr", "!=", "nil", "{", "if", "cef", ":=", "td", ".", "CleanupErrFunc", ";", "cef", "!=", "nil", "{", "cef", "(", "tdir", ",", "rmErr", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "fn", "(", "tdir", ")", "\n", "}" ]

[ "With", "creates", "a", "temporary", "directory", "and", "passes", "it", "to", "fn", ".", "After", "fn", "exits", "the", "directory", "and", "all", "of", "its", "contents", "is", "deleted", ".", "Any", "error", "that", "happens", "during", "setup", "or", "execution", "of", "the", "callback", "is", "returned", ".", "If", "an", "error", "occurs", "during", "cleanup", "the", "optional", "CleanupErrFunc", "will", "be", "called", "." ]

[ "func", "initMapper", "(", "d", "mapperDef", ")", "{", "if", "_", ",", "ok", ":=", "mappers", "[", "d", ".", "Kind", "]", ";", "ok", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "d", ".", "Kind", ")", ")", "\n", "}", "\n", "mappers", "[", "d", ".", "Kind", "]", "=", "&", "d", "\n", "}" ]

[ "initMapper", "is", "called", "during", "init", "time", "to", "register", "some", "mapper", "kind", "." ]

[ "func", "(", "m", "*", "mapperDef", ")", "newMapper", "(", "c", "context", ".", "Context", ",", "j", "*", "mapper", ".", "Job", ",", "shardIdx", "int", ")", "(", "mapper", ".", "Mapper", ",", "error", ")", "{", "cfg", ":=", "&", "api", ".", "JobConfig", "{", "}", "\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "j", ".", "Config", ".", "Params", ",", "cfg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "func", "(", "c", "context", ".", "Context", ",", "keys", "[", "]", "*", "datastore", ".", "Key", ")", "error", "{", "return", "m", ".", "Func", "(", "c", ",", "j", ".", "ID", ",", "cfg", ",", "keys", ")", "\n", "}", ",", "nil", "\n", "}" ]

[ "newMapper", "creates", "new", "instance", "of", "a", "mapping", "function", "." ]

[ "func", "getReadItem", "(", "row", "bigtable", ".", "Row", ",", "family", ",", "column", "string", ")", "*", "bigtable", ".", "ReadItem", "{", "// Get the row for our family.", "items", ",", "ok", ":=", "row", "[", "logColumnFamily", "]", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n\n", "// Get the specific ReadItem for our column", "colName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "family", ",", "column", ")", "\n", "for", "_", ",", "item", ":=", "range", "items", "{", "if", "item", ".", "Column", "==", "colName", "{", "return", "&", "item", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "getReadItem", "retrieves", "a", "specific", "RowItem", "from", "the", "supplied", "Row", "." ]

[ "func", "isTextContent", "(", "h", "http", ".", "Header", ")", "bool", "{", "for", "_", ",", "header", ":=", "range", "h", "[", "\"", "\"", "]", "{", "for", "_", ",", "good", ":=", "range", "textContentTypes", "{", "if", "strings", ".", "HasPrefix", "(", "header", ",", "good", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isTextContent", "returns", "True", "if", "Content", "-", "Type", "header", "corresponds", "to", "some", "readable", "text", "type", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "WithoutWheels", "(", ")", "*", "Config", "{", "if", "!", "cfg", ".", "HasWheels", "(", ")", "{", "return", "cfg", "\n", "}", "\n\n", "clone", ":=", "*", "cfg", "\n", "clone", ".", "OverrideName", "=", "\"", "\"", "\n", "clone", ".", "Spec", "=", "clone", ".", "Spec", ".", "Clone", "(", ")", "\n", "clone", ".", "Spec", ".", "Wheel", "=", "nil", "\n", "return", "&", "clone", "\n", "}" ]

[ "WithoutWheels", "returns", "a", "clone", "of", "cfg", "that", "depends", "on", "no", "additional", "packages", ".", "If", "cfg", "is", "already", "an", "empty", "it", "will", "be", "returned", "directly", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "HasWheels", "(", ")", "bool", "{", "return", "cfg", ".", "Spec", "!=", "nil", "&&", "len", "(", "cfg", ".", "Spec", ".", "Wheel", ")", ">", "0", "\n", "}" ]

[ "HasWheels", "returns", "true", "if", "this", "environment", "declares", "wheel", "dependencies", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "makeEnv", "(", "c", "context", ".", "Context", ",", "e", "*", "vpython", ".", "Environment", ")", "(", "*", "Env", ",", "error", ")", "{", "// We MUST have a package loader.", "if", "cfg", ".", "Loader", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Resolve our base directory, if one is not supplied.", "if", "cfg", ".", "BaseDir", "==", "\"", "\"", "{", "// Use one in a temporary directory.", "cfg", ".", "BaseDir", "=", "filepath", ".", "Join", "(", "os", ".", "TempDir", "(", ")", ",", "\"", "\"", ")", "\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "cfg", ".", "BaseDir", ")", "\n", "}", "\n", "if", "err", ":=", "filesystem", ".", "AbsPath", "(", "&", "cfg", ".", "BaseDir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Construct a new, independent Environment for this Env.", "e", "=", "e", ".", "Clone", "(", ")", "\n", "if", "cfg", ".", "Spec", "!=", "nil", "{", "e", ".", "Spec", "=", "cfg", ".", "Spec", ".", "Clone", "(", ")", "\n", "}", "\n", "if", "err", ":=", "spec", ".", "NormalizeEnvironment", "(", "e", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// If the environment doesn't specify a VirtualEnv package (expected), use", "// our default.", "if", "e", ".", "Spec", ".", "Virtualenv", "==", "nil", "{", "e", ".", "Spec", ".", "Virtualenv", "=", "&", "cfg", ".", "Package", "\n", "}", "\n\n", "if", "err", ":=", "cfg", ".", "Loader", ".", "Resolve", "(", "c", ",", "e", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "if", "err", ":=", "cfg", ".", "resolvePythonInterpreter", "(", "c", ",", "e", ".", "Spec", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "e", ".", "Runtime", "=", "&", "vpython", ".", "Runtime", "{", "Version", ":", "e", ".", "Spec", ".", "PythonVersion", ",", "}", "\n", "if", "err", ":=", "fillRuntime", "(", "c", ",", "cfg", ".", "si", ",", "e", ".", "Runtime", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "e", ".", "Runtime", ")", "\n\n", "// Ensure that our base directory exists.", "if", "err", ":=", "filesystem", ".", "MakeDirs", "(", "cfg", ".", "BaseDir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "cfg", ".", "BaseDir", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Generate our environment name based on the deterministic hash of its", "// fully-resolved specification.", "envName", ":=", "cfg", ".", "OverrideName", "\n", "if", "envName", "==", "\"", "\"", "{", "envName", "=", "cfg", ".", "envNameForSpec", "(", "c", ",", "e", ".", "Spec", ",", "e", ".", "Runtime", ")", "\n", "}", "\n", "env", ":=", "cfg", ".", "envForName", "(", "envName", ",", "e", ")", "\n", "return", "env", ",", "nil", "\n", "}" ]

[ "makeEnv", "processes", "the", "config", "validating", "and", "where", "appropriate", "populating", "any", "components", ".", "Upon", "success", "it", "returns", "a", "configured", "Env", "instance", ".", "The", "supplied", "vpython", ".", "Environment", "is", "derived", "externally", "and", "may", "be", "nil", "if", "this", "is", "a", "bootstrapped", "Environment", ".", "The", "returned", "Env", "instance", "may", "or", "may", "not", "actually", "exist", ".", "Setup", "must", "be", "called", "prior", "to", "using", "it", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "envNameForSpec", "(", "c", "context", ".", "Context", ",", "s", "*", "vpython", ".", "Spec", ",", "rt", "*", "vpython", ".", "Runtime", ")", "string", "{", "uid", ":=", "\"", "\"", "\n", "if", "user", ",", "err", ":=", "user", ".", "Current", "(", ")", ";", "err", "==", "nil", "{", "uid", "=", "user", ".", "Uid", "\n", "}", "else", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "name", ":=", "spec", ".", "Hash", "(", "s", ",", "rt", ",", "EnvironmentVersion", ",", "string", "(", "assets", ".", "GetAssetSHA256", "(", "siteCustomizePy", ")", ")", ",", "uid", ")", "\n", "if", "cfg", ".", "MaxHashLen", ">", "0", "&&", "len", "(", "name", ")", ">", "cfg", ".", "MaxHashLen", "{", "name", "=", "name", "[", ":", "cfg", ".", "MaxHashLen", "]", "\n", "}", "\n", "return", "name", "\n", "}" ]

[ "EnvName", "returns", "the", "VirtualEnv", "environment", "name", "for", "the", "environment", "that", "cfg", "describes", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "Prune", "(", "c", "context", ".", "Context", ")", "error", "{", "if", "err", ":=", "prune", "(", "c", ",", "cfg", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Prune", "performs", "a", "pruning", "round", "on", "the", "environment", "set", "described", "by", "this", "Config", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "envForName", "(", "name", "string", ",", "e", "*", "vpython", ".", "Environment", ")", "*", "Env", "{", "// Env-specific root directory: <BaseDir>/<name>", "venvRoot", ":=", "filepath", ".", "Join", "(", "cfg", ".", "BaseDir", ",", "name", ")", "\n", "binDir", ":=", "venvBinDir", "(", "venvRoot", ")", "\n", "return", "&", "Env", "{", "Config", ":", "cfg", ",", "Root", ":", "venvRoot", ",", "Name", ":", "name", ",", "Python", ":", "filepath", ".", "Join", "(", "binDir", ",", "\"", "\"", ")", ",", "Environment", ":", "e", ",", "BinDir", ":", "binDir", ",", "EnvironmentStampPath", ":", "filepath", ".", "Join", "(", "venvRoot", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "vpython", ".", "Version", ")", ")", ",", "lockPath", ":", "filepath", ".", "Join", "(", "cfg", ".", "BaseDir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", ",", "completeFlagPath", ":", "filepath", ".", "Join", "(", "venvRoot", ",", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "envForName", "creates", "an", "Env", "for", "a", "named", "directory", ".", "The", "Environment", "e", "can", "be", "nil", ";", "however", "code", "paths", "that", "require", "it", "may", "not", "be", "called", "." ]

[ "func", "fillRuntime", "(", "c", "context", ".", "Context", ",", "i", "*", "python", ".", "Interpreter", ",", "r", "*", "vpython", ".", "Runtime", ")", "error", "{", "// JSON fields correspond to \"vpython.Runtime\" fields.", "const", "script", "=", "``", "+", "`import json, sys;`", "+", "`json.dump({`", "+", "`'path': sys.executable,`", "+", "`'prefix': sys.prefix,`", "+", "`}, sys.stdout)`", "\n\n", "// Probe the runtime information.", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n", "cmd", ":=", "i", ".", "IsolatedCommand", "(", "c", ",", "python", ".", "CommandTarget", "{", "Command", ":", "script", "}", ")", "\n", "cmd", ".", "Stdout", "=", "&", "stdout", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\\n", "\"", ",", "stderr", ".", "Bytes", "(", ")", ")", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "stdout", ".", "Bytes", "(", ")", ",", "r", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "stdout", ".", "Bytes", "(", ")", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// \"sys.executable\" is allowed to be None. If it is, use the Python", "// interpreter path.", "//", "// Resolve it to an absolute path. \"sys.executable\" says that it must be one,", "// but we'll enforce it just to be sure.", "if", "r", ".", "Path", "==", "\"", "\"", "{", "r", ".", "Path", "=", "i", ".", "Python", "\n", "}", "\n", "if", "err", ":=", "filesystem", ".", "AbsPath", "(", "&", "r", ".", "Path", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "err", "error", "\n", "if", "r", ".", "Hash", ",", "err", "=", "hashPath", "(", "r", ".", "Path", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "fillRuntime", "returns", "the", "runtime", "information", "of", "the", "specified", "interpreter", ".", "Identifying", "this", "information", "requires", "the", "interpreter", "to", "be", "run", "." ]

[ "func", "gofmt", "(", "blob", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "out", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "cmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Stdin", "=", "bytes", ".", "NewReader", "(", "blob", ")", "\n", "cmd", ".", "Stdout", "=", "&", "out", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "out", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "gofmt", "applies", "gofmt", "-", "s", "to", "the", "content", "of", "the", "buffer", "." ]

[ "func", "compress", "(", "data", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "buf", "bytes", ".", "Buffer", "\n", "w", ":=", "gzip", ".", "NewWriter", "(", "&", "buf", ")", "\n", "if", "_", ",", "err", ":=", "w", ".", "Write", "(", "data", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "w", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "buf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "compress", "compresses", "data", "with", "gzip", "." ]

[ "func", "calcDigest", "(", "inputs", "map", "[", "string", "]", "[", "]", "byte", ")", "string", "{", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "inputs", ")", ")", "\n", "for", "k", ":=", "range", "inputs", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "h", ":=", "sha1", ".", "New", "(", ")", "\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "v", ":=", "inputs", "[", "k", "]", "\n", "fmt", ".", "Fprintf", "(", "h", ",", "\"", "\\n", "\\n", "\"", ",", "k", ",", "len", "(", "v", ")", ")", "\n", "h", ".", "Write", "(", "v", ")", "\n", "}", "\n", "blob", ":=", "h", ".", "Sum", "(", "nil", ")", "\n", "return", "hex", ".", "EncodeToString", "(", "blob", "[", ":", "]", ")", "\n", "}" ]

[ "calcDigest", "produces", "a", "digest", "of", "a", "given", "map", "using", "some", "stable", "serialization", "." ]

[ "func", "Default", "(", ")", "Func", "{", "f", ",", "err", ":=", "New", "(", "&", "defaultPolicy", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "return", "f", "\n", "}" ]

[ "Default", "instantiates", "default", "triggering", "policy", "function", ".", "Is", "is", "used", "if", "jobs", "do", "not", "define", "a", "triggering", "policy", "or", "it", "can", "t", "be", "understood", "." ]

[ "func", "UnmarshalDefinition", "(", "b", "[", "]", "byte", ")", "(", "*", "messages", ".", "TriggeringPolicy", ",", "error", ")", "{", "msg", ":=", "&", "messages", ".", "TriggeringPolicy", "{", "}", "\n", "if", "len", "(", "b", ")", "!=", "0", "{", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "b", ",", "msg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n", "if", "msg", ".", "Kind", "==", "0", "{", "msg", ".", "Kind", "=", "defaultPolicy", ".", "Kind", "\n", "}", "\n", "if", "msg", ".", "MaxConcurrentInvocations", "==", "0", "{", "msg", ".", "MaxConcurrentInvocations", "=", "defaultPolicy", ".", "MaxConcurrentInvocations", "\n", "}", "\n", "if", "msg", ".", "MaxBatchSize", "==", "0", "{", "msg", ".", "MaxBatchSize", "=", "defaultPolicy", ".", "MaxBatchSize", "\n", "}", "\n", "return", "msg", ",", "nil", "\n", "}" ]

[ "UnmarshalDefinition", "deserializes", "TriggeringPolicy", "filling", "in", "defaults", "." ]

[ "func", "readFilesInDir", "(", "dir", "string", ",", "out", "map", "[", "string", "]", "string", ")", "error", "{", "_", ",", "err", ":=", "os", ".", "Stat", "(", "dir", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", "\n", "}", "\n", "return", "filepath", ".", "Walk", "(", "dir", ",", "func", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "||", "info", ".", "IsDir", "(", ")", "{", "return", "err", "\n", "}", "\n", "body", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "==", "nil", "{", "out", "[", "path", "]", "=", "string", "(", "body", ")", "\n", "}", "\n", "return", "err", "\n", "}", ")", "\n", "}" ]

[ "readFilesInDir", "loads", "content", "of", "files", "into", "a", "map", "file", "path", "=", ">", "content", ".", "Used", "only", "for", "small", "HTML", "templates", "and", "thus", "it", "s", "fine", "to", "load", "them", "in", "memory", ".", "Does", "nothing", "is", "dir", "is", "missing", "." ]

[ "func", "NewServer", "(", ")", "*", "AdminServer", "{", "signer", ":=", "gaesigner", ".", "Signer", "{", "}", "\n", "return", "&", "AdminServer", "{", "ImportDelegationConfigsRPC", ":", "delegation", ".", "ImportDelegationConfigsRPC", "{", "RulesCache", ":", "delegation", ".", "GlobalRulesCache", ",", "}", ",", "InspectDelegationTokenRPC", ":", "delegation", ".", "InspectDelegationTokenRPC", "{", "Signer", ":", "signer", ",", "}", ",", "InspectMachineTokenRPC", ":", "machinetoken", ".", "InspectMachineTokenRPC", "{", "Signer", ":", "signer", ",", "}", ",", "ImportServiceAccountsConfigsRPC", ":", "serviceaccounts", ".", "ImportServiceAccountsConfigsRPC", "{", "RulesCache", ":", "serviceaccounts", ".", "GlobalRulesCache", ",", "}", ",", "InspectOAuthTokenGrantRPC", ":", "serviceaccounts", ".", "InspectOAuthTokenGrantRPC", "{", "Signer", ":", "signer", ",", "Rules", ":", "serviceaccounts", ".", "GlobalRulesCache", ".", "Rules", ",", "}", ",", "ImportProjectIdentityConfigsRPC", ":", "projectscope", ".", "ImportProjectIdentityConfigsRPC", "{", "}", ",", "}", "\n", "}" ]

[ "NewServer", "returns", "prod", "AdminServer", "implementation", ".", "It", "assumes", "authorization", "has", "happened", "already", "." ]

[ "func", "isReadOnly", "(", "methodName", "string", ")", "bool", "{", "return", "strings", ".", "HasPrefix", "(", "methodName", ",", "\"", "\"", ")", "||", "strings", ".", "HasPrefix", "(", "methodName", ",", "\"", "\"", ")", "\n", "}" ]

[ "isReadOnly", "returns", "whether", "the", "given", "method", "name", "is", "for", "a", "read", "-", "only", "method", "." ]

[ "func", "readOnlyAuthPrelude", "(", "c", "context", ".", "Context", ",", "methodName", "string", ",", "req", "proto", ".", "Message", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "if", "!", "isReadOnly", "(", "methodName", ")", "{", "return", "c", ",", "status", ".", "Errorf", "(", "codes", ".", "PermissionDenied", ",", "\"", "\"", ")", "\n", "}", "\n", "switch", "is", ",", "err", ":=", "auth", ".", "IsMember", "(", "c", ",", "admins", ",", "writers", ",", "readers", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "c", ",", "err", "\n", "case", "is", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\\n", "\"", ",", "auth", ".", "CurrentIdentity", "(", "c", ")", ",", "methodName", ",", "req", ")", "\n", "return", "c", ",", "nil", "\n", "}", "\n", "return", "c", ",", "status", ".", "Errorf", "(", "codes", ".", "PermissionDenied", ",", "\"", "\"", ")", "\n", "}" ]

[ "readOnlyAuthPrelude", "ensures", "the", "user", "is", "authorized", "to", "use", "read", "API", "methods", ".", "Always", "returns", "permission", "denied", "for", "write", "API", "methods", "." ]

[ "func", "vmAccessPrelude", "(", "c", "context", ".", "Context", ",", "methodName", "string", ",", "req", "proto", ".", "Message", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "groups", ":=", "[", "]", "string", "{", "admins", ",", "writers", "}", "\n", "if", "isReadOnly", "(", "methodName", ")", "{", "groups", "=", "append", "(", "groups", ",", "readers", ")", "\n", "}", "\n", "switch", "is", ",", "err", ":=", "auth", ".", "IsMember", "(", "c", ",", "groups", "...", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "c", ",", "err", "\n", "case", "is", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\\n", "\"", ",", "auth", ".", "CurrentIdentity", "(", "c", ")", ",", "methodName", ",", "req", ")", "\n", "// Remove the VM token to avoid restricting the user's broad access.", "return", "vmtoken", ".", "Clear", "(", "c", ")", ",", "nil", "\n", "case", "isVMAccessible", "(", "methodName", ")", "&&", "vmtoken", ".", "Has", "(", "c", ")", ":", "logging", ".", "Debugf", "(", "c", ",", "\"", "\\n", "\"", ",", "vmtoken", ".", "CurrentIdentity", "(", "c", ")", ",", "methodName", ",", "req", ")", "\n", "return", "c", ",", "nil", "\n", "}", "\n", "return", "c", ",", "status", ".", "Errorf", "(", "codes", ".", "PermissionDenied", ",", "\"", "\"", ")", "\n", "}" ]

[ "vmAccessPrelude", "ensures", "the", "user", "is", "authorized", "to", "use", "the", "API", "or", "has", "presented", "a", "valid", "GCE", "VM", "token", "and", "is", "attempting", "to", "use", "VM", "-", "accessible", "API", ".", "Users", "of", "this", "prelude", "must", "perform", "additional", "authorization", "checks", "in", "methods", "accepted", "by", "isVMAccessible", "." ]

[ "func", "Filter", "(", "err", "error", ",", "exclude", "error", ",", "others", "...", "error", ")", "error", "{", "return", "FilterFunc", "(", "err", ",", "func", "(", "e", "error", ")", "bool", "{", "if", "e", "==", "exclude", "{", "return", "true", "\n", "}", "\n", "for", "_", ",", "v", ":=", "range", "others", "{", "if", "e", "==", "v", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n", "}" ]

[ "Filter", "examines", "a", "supplied", "error", "and", "removes", "instances", "of", "excluded", "errors", "from", "it", ".", "If", "the", "entire", "supplied", "error", "is", "excluded", "Filter", "will", "return", "nil", ".", "If", "a", "MultiError", "is", "supplied", "to", "Filter", "it", "will", "be", "recursively", "traversed", "and", "its", "child", "errors", "will", "be", "turned", "into", "nil", "if", "they", "match", "the", "supplied", "filter", ".", "If", "a", "MultiError", "has", "all", "of", "its", "children", "converted", "to", "nil", "as", "a", "result", "of", "the", "filter", "it", "will", "itself", "be", "reduced", "to", "nil", "." ]

[ "func", "FilterFunc", "(", "err", "error", ",", "shouldFilter", "func", "(", "error", ")", "bool", ")", "error", "{", "switch", "{", "case", "shouldFilter", "==", "nil", ":", "return", "err", "\n", "case", "err", "==", "nil", ":", "return", "nil", "\n", "case", "shouldFilter", "(", "err", ")", ":", "return", "nil", "\n", "}", "\n\n", "if", "merr", ",", "ok", ":=", "err", ".", "(", "MultiError", ")", ";", "ok", "{", "var", "lme", "MultiError", "\n", "for", "i", ",", "e", ":=", "range", "merr", "{", "if", "e", "!=", "nil", "{", "e", "=", "FilterFunc", "(", "e", ",", "shouldFilter", ")", "\n", "if", "e", "!=", "nil", "{", "if", "lme", "==", "nil", "{", "lme", "=", "make", "(", "MultiError", ",", "len", "(", "merr", ")", ")", "\n", "}", "\n", "lme", "[", "i", "]", "=", "e", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "lme", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "lme", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "FilterFunc", "examines", "a", "supplied", "error", "and", "removes", "instances", "of", "errors", "that", "match", "the", "supplied", "filter", "function", ".", "If", "the", "entire", "supplied", "error", "is", "removed", "FilterFunc", "will", "return", "nil", ".", "If", "a", "MultiError", "is", "supplied", "to", "FilterFunc", "it", "will", "be", "recursively", "traversed", "and", "its", "child", "errors", "will", "be", "turned", "into", "nil", "if", "they", "match", "the", "supplied", "filter", "function", ".", "If", "a", "MultiError", "has", "all", "of", "its", "children", "converted", "to", "nil", "as", "a", "result", "of", "the", "filter", "it", "will", "itself", "be", "reduced", "to", "nil", ".", "Consqeuently", "if", "err", "is", "a", "MultiError", "shouldFilter", "will", "be", "called", "once", "with", "err", "as", "its", "value", "and", "once", "for", "every", "non", "-", "nil", "error", "that", "it", "contains", "." ]

[ "func", "(", "op", "*", "Operation", ")", "ToProto", "(", "wrappedID", "string", ")", "*", "api", ".", "UploadOperation", "{", "var", "ref", "*", "api", ".", "ObjectRef", "\n", "if", "op", ".", "Status", "==", "api", ".", "UploadStatus_PUBLISHED", "{", "ref", "=", "&", "api", ".", "ObjectRef", "{", "HashAlgo", ":", "op", ".", "HashAlgo", ",", "HexDigest", ":", "op", ".", "HexDigest", ",", "}", "\n", "}", "\n", "return", "&", "api", ".", "UploadOperation", "{", "OperationId", ":", "wrappedID", ",", "UploadUrl", ":", "op", ".", "UploadURL", ",", "Status", ":", "op", ".", "Status", ",", "Object", ":", "ref", ",", "ErrorMessage", ":", "op", ".", "Error", ",", "}", "\n", "}" ]

[ "ToProto", "constructs", "UploadOperation", "proto", "message", ".", "The", "caller", "must", "prepare", "the", "ID", "in", "advance", "using", "WrapOpID", "." ]

[ "func", "ServiceConfigPath", "(", "c", "context", ".", "Context", ")", "(", "config", ".", "Set", ",", "string", ")", "{", "return", "cfgclient", ".", "CurrentServiceConfigSet", "(", "c", ")", ",", "svcconfig", ".", "ServiceConfigPath", "\n", "}" ]

[ "ServiceConfigPath", "returns", "the", "config", "set", "and", "path", "for", "this", "application", "s", "service", "configuration", "." ]

[ "func", "validateServiceConfig", "(", "cc", "*", "svcconfig", ".", "Config", ")", "error", "{", "switch", "{", "case", "cc", "==", "nil", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "cc", ".", "GetCoordinator", "(", ")", "==", "nil", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}" ]

[ "validateServiceConfig", "checks", "the", "supplied", "service", "config", "object", "to", "ensure", "that", "it", "meets", "a", "minimum", "configuration", "standard", "expected", "by", "our", "endpoitns", "and", "handlers", "." ]

[ "func", "IsAllowed", "(", "c", "context", ".", "Context", ",", "project", "string", ")", "(", "bool", ",", "error", ")", "{", "switch", "admin", ",", "err", ":=", "IsAdmin", "(", "c", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "false", ",", "err", "\n", "case", "admin", ":", "return", "true", ",", "nil", "\n", "}", "\n\n", "// Get the project, because that's where the ACLs lie.", "err", ":=", "access", ".", "Check", "(", "c", ",", "backend", ".", "AsUser", ",", "config", ".", "ProjectSet", "(", "project", ")", ")", "\n", "innerError", ":=", "errors", ".", "Unwrap", "(", "err", ")", "\n\n", "switch", "{", "case", "err", "==", "nil", ":", "return", "true", ",", "nil", "\n", "case", "err", "==", "access", ".", "ErrNoAccess", ":", "return", "false", ",", "nil", "\n", "case", "innerError", "==", "config", ".", "ErrNoConfig", ":", "return", "false", ",", "grpcutil", ".", "NotFoundTag", ".", "Apply", "(", "err", ")", "\n", "default", ":", "return", "false", ",", "err", "\n", "}", "\n", "}" ]

[ "Helper", "functions", "for", "ACL", "checking", ".", "IsAllowed", "checks", "to", "see", "if", "the", "user", "in", "the", "context", "is", "allowed", "to", "access", "the", "given", "project", "." ]

[ "func", "NewAccessClient", "(", "c", "context", ".", "Context", ")", "(", "*", "AccessClient", ",", "error", ")", "{", "settings", ":=", "GetSettings", "(", "c", ")", "\n", "if", "settings", ".", "Buildbucket", ".", "GetHost", "(", ")", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "t", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "c", ",", "auth", ".", "AsUser", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "&", "AccessClient", "{", "AccessClient", ":", "bbAccess", ".", "NewClient", "(", "settings", ".", "Buildbucket", ".", "Host", ",", "&", "http", ".", "Client", "{", "Transport", ":", "t", "}", ")", ",", "Host", ":", "settings", ".", "Buildbucket", ".", "Host", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAccessClient", "creates", "a", "new", "AccessClient", "for", "talking", "to", "this", "milo", "instance", "s", "buildbucket", "instance", "." ]

[ "func", "WithAccessClient", "(", "c", "context", ".", "Context", ",", "a", "*", "AccessClient", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "&", "accessClientKey", ",", "a", ")", "\n", "}" ]

[ "WithAccessClient", "attaches", "an", "AccessClient", "to", "the", "given", "context", "." ]

[ "func", "GetAccessClient", "(", "c", "context", ".", "Context", ")", "*", "AccessClient", "{", "if", "client", ",", "ok", ":=", "c", ".", "Value", "(", "&", "accessClientKey", ")", ".", "(", "*", "AccessClient", ")", ";", "!", "ok", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "else", "{", "return", "client", "\n", "}", "\n", "}" ]

[ "GetAccessClient", "retrieves", "an", "AccessClient", "from", "the", "given", "context", "." ]

[ "func", "adminPrelude", "(", "serviceName", "string", ")", "func", "(", "context", ".", "Context", ",", "string", ",", "proto", ".", "Message", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "return", "func", "(", "c", "context", ".", "Context", ",", "method", "string", ",", "_", "proto", ".", "Message", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "serviceName", ",", "auth", ".", "CurrentIdentity", "(", "c", ")", ",", "method", ")", "\n", "switch", "admin", ",", "err", ":=", "auth", ".", "IsMember", "(", "c", ",", "\"", "\"", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "case", "!", "admin", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "PermissionDenied", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "c", ",", "nil", "\n", "}", "\n", "}" ]

[ "adminPrelude", "returns", "a", "prelude", "that", "authorizes", "only", "administrators", "." ]

[ "func", "(", "t", "*", "File_Template", ")", "Normalize", "(", ")", "error", "{", "if", "t", ".", "Body", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "defaultParams", ":=", "make", "(", "map", "[", "string", "]", "*", "Value", ",", "len", "(", "t", ".", "Param", ")", ")", "\n", "for", "k", ",", "param", ":=", "range", "t", ".", "Param", "{", "if", "k", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "if", "!", "ParamRegex", ".", "MatchString", "(", "k", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "if", "!", "strings", ".", "Contains", "(", "t", ".", "Body", ",", "k", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "if", "err", ":=", "param", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ",", "err", ")", "\n", "}", "\n", "if", "param", ".", "Default", "!=", "nil", "{", "defaultParams", "[", "k", "]", "=", "param", ".", "Default", "\n", "}", "else", "{", "defaultParams", "[", "k", "]", "=", "param", ".", "Schema", ".", "Zero", "(", ")", "\n", "}", "\n", "}", "\n\n", "maybeJSON", ",", "err", ":=", "t", ".", "Render", "(", "defaultParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "maybeJSON", ")", ",", "&", "map", "[", "string", "]", "interface", "{", "}", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "will", "normalize", "the", "Template", "message", "returning", "an", "error", "if", "it", "is", "invalid", "." ]

[ "func", "(", "p", "*", "File_Template_Parameter", ")", "Normalize", "(", ")", "error", "{", "if", "p", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "p", ".", "Schema", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "p", ".", "Default", "!=", "nil", "{", "if", "err", ":=", "p", ".", "Default", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "p", ".", "Accepts", "(", "p", ".", "Default", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "will", "normalize", "the", "Parameter", "returning", "an", "error", "if", "it", "is", "invalid", "." ]

[ "func", "(", "p", "*", "File_Template_Parameter", ")", "Accepts", "(", "v", "*", "Value", ")", "error", "{", "if", "v", ".", "IsNull", "(", ")", "{", "if", "!", "p", ".", "Nullable", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "if", "err", ":=", "p", ".", "Schema", ".", "Accepts", "(", "v", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "err", ":=", "v", ".", "Check", "(", "p", ".", "Schema", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Accepts", "returns", "nil", "if", "this", "Parameter", "can", "accept", "the", "Value", "." ]

[ "func", "(", "s", "*", "Schema", ")", "Normalize", "(", ")", "error", "{", "if", "s", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "s", ".", "Schema", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "enum", ":=", "s", ".", "GetEnum", "(", ")", ";", "enum", "!=", "nil", "{", "return", "enum", ".", "Normalize", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "will", "normalize", "the", "Schema", "returning", "an", "error", "if", "it", "is", "invalid", "." ]

[ "func", "(", "s", "*", "Schema_Set", ")", "Normalize", "(", ")", "error", "{", "if", "len", "(", "s", ".", "Entry", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "set", ":=", "stringset", ".", "New", "(", "len", "(", "s", ".", "Entry", ")", ")", "\n", "for", "_", ",", "entry", ":=", "range", "s", ".", "Entry", "{", "if", "entry", ".", "Token", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "set", ".", "Add", "(", "entry", ".", "Token", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "entry", ".", "Token", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "will", "normalize", "the", "Schema_Set", "returning", "an", "error", "if", "it", "is", "invalid", "." ]

[ "func", "(", "s", "*", "Schema_Set", ")", "Has", "(", "token", "string", ")", "bool", "{", "for", "_", ",", "tok", ":=", "range", "s", ".", "Entry", "{", "if", "tok", ".", "Token", "==", "token", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Has", "returns", "true", "iff", "the", "given", "token", "is", "a", "valid", "value", "for", "this", "enumeration", "." ]

[ "func", "(", "v", "*", "Value", ")", "IsNull", "(", ")", "bool", "{", "_", ",", "ret", ":=", "v", ".", "Value", ".", "(", "*", "Value_Null", ")", "\n", "return", "ret", "\n", "}" ]

[ "IsNull", "returns", "true", "if", "this", "Value", "is", "the", "null", "value", "." ]

[ "func", "(", "v", "*", "Value", ")", "Check", "(", "s", "*", "Schema", ")", "error", "{", "check", ",", "needsCheck", ":=", "v", ".", "Value", ".", "(", "interface", "{", "Check", "(", "*", "Schema", ")", "error", "\n", "}", ")", "\n", "if", "!", "needsCheck", "{", "return", "nil", "\n", "}", "\n", "return", "check", ".", "Check", "(", "s", ")", "\n", "}" ]

[ "Check", "ensures", "that", "this", "value", "conforms", "to", "the", "given", "schema", "." ]

[ "func", "(", "v", "*", "Value", ")", "Normalize", "(", ")", "error", "{", "norm", ",", "needsNormalization", ":=", "v", ".", "Value", ".", "(", "interface", "{", "Normalize", "(", ")", "error", "\n", "}", ")", "\n", "if", "!", "needsNormalization", "{", "return", "nil", "\n", "}", "\n", "return", "norm", ".", "Normalize", "(", ")", "\n", "}" ]

[ "Normalize", "returns", "a", "non", "-", "nil", "error", "if", "the", "Value", "is", "invalid", "for", "its", "nominal", "type", "." ]

[ "func", "(", "v", "*", "Value_Bytes", ")", "Check", "(", "schema", "*", "Schema", ")", "error", "{", "s", ":=", "schema", ".", "GetBytes", "(", ")", "\n", "if", "s", ".", "MaxLength", ">", "0", "&&", "uint32", "(", "len", "(", "v", ".", "Bytes", ")", ")", ">", "s", ".", "MaxLength", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "v", ".", "Bytes", ")", ",", "s", ".", "MaxLength", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Check", "returns", "nil", "iff", "this", "Value", "meets", "the", "max", "length", "criteria", "." ]

[ "func", "(", "v", "*", "Value_Object", ")", "Check", "(", "schema", "*", "Schema", ")", "error", "{", "s", ":=", "schema", ".", "GetObject", "(", ")", "\n", "if", "s", ".", "MaxLength", ">", "0", "&&", "uint32", "(", "len", "(", "v", ".", "Object", ")", ")", ">", "s", ".", "MaxLength", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "v", ".", "Object", ")", ",", "s", ".", "MaxLength", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Check", "returns", "nil", "iff", "this", "Value", "correctly", "parses", "as", "a", "JSON", "object", "." ]

[ "func", "(", "v", "*", "Value_Object", ")", "Normalize", "(", ")", "error", "{", "newObj", ",", "err", ":=", "NormalizeJSON", "(", "v", ".", "Object", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "v", ".", "Object", "=", "newObj", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "returns", "nil", "iff", "this", "Value", "correctly", "parses", "as", "a", "JSON", "object", "." ]

[ "func", "(", "v", "*", "Value_Array", ")", "Check", "(", "schema", "*", "Schema", ")", "error", "{", "s", ":=", "schema", ".", "GetArray", "(", ")", "\n", "if", "s", ".", "MaxLength", ">", "0", "&&", "uint32", "(", "len", "(", "v", ".", "Array", ")", ")", ">", "s", ".", "MaxLength", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "v", ".", "Array", ")", ",", "s", ".", "MaxLength", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Check", "returns", "nil", "iff", "this", "Value", "correctly", "parses", "as", "a", "JSON", "array", "." ]

[ "func", "(", "v", "*", "Value_Array", ")", "Normalize", "(", ")", "error", "{", "newAry", ",", "err", ":=", "NormalizeJSON", "(", "v", ".", "Array", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "v", ".", "Array", "=", "newAry", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "returns", "nil", "iff", "this", "Value", "correctly", "parses", "as", "a", "JSON", "array", "." ]