Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "addNICCmd", "(", "params", "*", "Parameters", ")", "*", "subcommands", ".", "Command", "{", "return", "&", "subcommands", ".", "Command", "{", "UsageLine", ":", "\"", "\"", ",", "ShortDesc", ":", "\"", "\"", ",", "LongDesc", ":", "\"", "\\n", "\\n", "\\n", "\"", ",", "CommandRun", ":", "func", "(", ")", "subcommands", ".", "CommandRun", "{", "cmd", ":=", "&", "AddNICCmd", "{", "}", "\n", "cmd", ".", "Initialize", "(", "params", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Name", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Machine", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "MacAddress", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Switch", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "Int32", "(", "&", "cmd", ".", "nic", ".", "Switchport", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Hostname", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Ipv4", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}", ",", "}", "\n", "}" ]

[ "addNICCmd", "returns", "a", "command", "to", "add", "a", "network", "interface", "." ]

[ "func", "deleteNICCmd", "(", "params", "*", "Parameters", ")", "*", "subcommands", ".", "Command", "{", "return", "&", "subcommands", ".", "Command", "{", "UsageLine", ":", "\"", "\"", ",", "ShortDesc", ":", "\"", "\"", ",", "LongDesc", ":", "\"", "\\n", "\\n", "\\n", "\"", ",", "CommandRun", ":", "func", "(", ")", "subcommands", ".", "CommandRun", "{", "cmd", ":=", "&", "DeleteNICCmd", "{", "}", "\n", "cmd", ".", "Initialize", "(", "params", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "req", ".", "Name", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "req", ".", "Machine", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}", ",", "}", "\n", "}" ]

[ "deleteNICCmd", "returns", "a", "command", "to", "delete", "a", "network", "interface", "." ]

[ "func", "(", "c", "*", "EditNICCmd", ")", "Run", "(", "app", "subcommands", ".", "Application", ",", "args", "[", "]", "string", ",", "env", "subcommands", ".", "Env", ")", "int", "{", "ctx", ":=", "cli", ".", "GetContext", "(", "app", ",", "c", ",", "env", ")", "\n", "// TODO(smut): Validate required fields client-side.", "req", ":=", "&", "crimson", ".", "UpdateNICRequest", "{", "Nic", ":", "&", "c", ".", "nic", ",", "UpdateMask", ":", "getUpdateMask", "(", "&", "c", ".", "Flags", ",", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "}", ")", ",", "}", "\n", "client", ":=", "getClient", "(", "ctx", ")", "\n", "resp", ",", "err", ":=", "client", ".", "UpdateNIC", "(", "ctx", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "errors", ".", "Log", "(", "ctx", ",", "err", ")", "\n", "return", "1", "\n", "}", "\n", "printNICs", "(", "c", ".", "f", ".", "tsv", ",", "resp", ")", "\n", "return", "0", "\n", "}" ]

[ "Run", "runs", "the", "command", "to", "edit", "a", "network", "interface", "." ]

[ "func", "editNICCmd", "(", "params", "*", "Parameters", ")", "*", "subcommands", ".", "Command", "{", "return", "&", "subcommands", ".", "Command", "{", "UsageLine", ":", "\"", "\"", ",", "ShortDesc", ":", "\"", "\"", ",", "LongDesc", ":", "\"", "\\n", "\\n", "\\n", "\"", ",", "CommandRun", ":", "func", "(", ")", "subcommands", ".", "CommandRun", "{", "cmd", ":=", "&", "EditNICCmd", "{", "}", "\n", "cmd", ".", "Initialize", "(", "params", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Name", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Machine", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "MacAddress", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "nic", ".", "Switch", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "Int32", "(", "&", "cmd", ".", "nic", ".", "Switchport", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}", ",", "}", "\n", "}" ]

[ "editNICCmd", "returns", "a", "command", "to", "edit", "a", "network", "interface", "." ]

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

[ "Run", "runs", "the", "command", "to", "get", "network", "interfaces", "." ]

[ "func", "getNICsCmd", "(", "params", "*", "Parameters", ")", "*", "subcommands", ".", "Command", "{", "return", "&", "subcommands", ".", "Command", "{", "UsageLine", ":", "\"", "\"", ",", "ShortDesc", ":", "\"", "\"", ",", "LongDesc", ":", "\"", "\\n", "\\n", "\\n", "\\n", "\\n", "\"", ",", "CommandRun", ":", "func", "(", ")", "subcommands", ".", "CommandRun", "{", "cmd", ":=", "&", "GetNICsCmd", "{", "}", "\n", "cmd", ".", "Initialize", "(", "params", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "req", ".", "Names", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "req", ".", "Machines", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "req", ".", "MacAddresses", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "req", ".", "Switches", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}", ",", "}", "\n", "}" ]

[ "getNICCmd", "returns", "a", "command", "to", "get", "network", "interfaces", "." ]

[ "func", "(", "r", "*", "Runner", ")", "init", "(", ")", "{", "r", ".", "initOnce", ".", "Do", "(", "func", "(", ")", "{", "r", ".", "workC", "=", "make", "(", "chan", "WorkItem", ")", "\n", "r", ".", "dispatchFinishedC", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n\n", "go", "r", ".", "dispatchLoop", "(", "r", ".", "Sustained", ",", "r", ".", "Maximum", ")", "\n", "}", ")", "\n", "}" ]

[ "init", "initializes", "the", "starting", "state", "of", "the", "Runner", ".", "It", "must", "be", "called", "at", "the", "beginning", "of", "all", "exported", "methods", "." ]

[ "func", "(", "r", "*", "Runner", ")", "dispatchLoop", "(", "sustained", "int", ",", "maximum", "int", ")", "{", "defer", "close", "(", "r", ".", "dispatchFinishedC", ")", "\n\n", "// If a Maximum is set, use Semaphore to enforce it.", "if", "maximum", ">", "0", "{", "spawnC", ":=", "make", "(", "Semaphore", ",", "maximum", ")", "\n", "r", ".", "dispatchLoopBody", "(", "sustained", ",", "spawnC", ".", "Lock", ",", "spawnC", ".", "Unlock", ")", "\n", "spawnC", ".", "TakeAll", "(", ")", "\n", "}", "else", "{", "// Unbounded number of goroutines. Use a WaitGroup to track them, and block", "// until all of the task goroutines have completed.", "var", "wg", "sync", ".", "WaitGroup", "\n", "r", ".", "dispatchLoopBody", "(", "sustained", ",", "func", "(", ")", "{", "wg", ".", "Add", "(", "1", ")", "}", ",", "wg", ".", "Done", ")", "\n", "wg", ".", "Wait", "(", ")", "\n", "}", "\n", "}" ]

[ "disaptchLoop", "is", "run", "in", "a", "goroutine", ".", "It", "reads", "tasks", "from", "workC", "and", "executes", "them", "." ]

[ "func", "(", "r", "*", "Runner", ")", "Close", "(", ")", "{", "r", ".", "init", "(", ")", "\n\n", "close", "(", "r", ".", "workC", ")", "\n", "<-", "r", ".", "dispatchFinishedC", "\n", "}" ]

[ "Close", "will", "instruct", "the", "Runner", "to", "not", "accept", "any", "more", "jobs", "and", "block", "until", "all", "current", "work", "is", "finished", ".", "Close", "may", "only", "be", "called", "once", ";", "additional", "calls", "will", "panic", ".", "The", "Runner", "s", "dispatch", "methods", "will", "panic", "if", "new", "work", "is", "dispatched", "after", "Close", "has", "been", "called", "." ]

[ "func", "(", "r", "*", "Runner", ")", "runThen", "(", "gen", "func", "(", "chan", "<-", "func", "(", ")", "error", ")", ",", "then", "func", "(", ")", ")", "<-", "chan", "error", "{", "r", ".", "init", "(", ")", "\n\n", "return", "runImpl", "(", "gen", ",", "r", ".", "workC", ",", "then", ")", "\n", "}" ]

[ "runThen", "is", "a", "thin", "wrapper", "around", "Run", "that", "enables", "an", "after", "call", "function", "to", "be", "invoked", "when", "the", "generator", "has", "finished", "." ]

[ "func", "runImpl", "(", "gen", "func", "(", "chan", "<-", "func", "(", ")", "error", ")", ",", "workC", "chan", "<-", "WorkItem", ",", "then", "func", "(", ")", ")", "<-", "chan", "error", "{", "errC", ":=", "make", "(", "chan", "error", ")", "\n", "taskC", ":=", "make", "(", "chan", "func", "(", ")", "error", ")", "\n\n", "// Execute our generator method.", "go", "func", "(", ")", "{", "defer", "close", "(", "taskC", ")", "\n", "gen", "(", "taskC", ")", "\n", "}", "(", ")", "\n\n", "// Read tasks from taskC and dispatch actual work.", "go", "func", "(", ")", "{", "if", "then", "!=", "nil", "{", "defer", "then", "(", ")", "\n", "}", "\n\n", "// Use a counter to track the number of active jobs.", "//", "// Add one implicit job for the outer task loop. This will ensure that if", "// we will never hit 0 until all of our tasks have dispatched.", "count", ":=", "int32", "(", "1", ")", "\n", "finish", ":=", "func", "(", ")", "{", "if", "atomic", ".", "AddInt32", "(", "&", "count", ",", "-", "1", ")", "==", "0", "{", "close", "(", "errC", ")", "\n", "}", "\n", "}", "\n", "defer", "finish", "(", ")", "\n\n", "// Dispatch the tasks in the task channel.", "for", "task", ":=", "range", "taskC", "{", "atomic", ".", "AddInt32", "(", "&", "count", ",", "1", ")", "\n", "workC", "<-", "WorkItem", "{", "F", ":", "task", ",", "ErrC", ":", "errC", ",", "After", ":", "finish", ",", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "errC", "\n", "}" ]

[ "runImpl", "sets", "up", "a", "localized", "system", "where", "a", "generator", "generates", "tasks", "and", "dispatches", "them", "to", "the", "supplied", "work", "channel", ".", "After", "all", "tasks", "have", "been", "written", "to", "the", "work", "channel", "then", "is", "called", "." ]

[ "func", "updateProject", "(", "c", "context", ".", "Context", ",", "cs", "*", "parsedProjectConfigSet", ")", "error", "{", "return", "datastore", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "project", ":=", "&", "Project", "{", "Name", ":", "cs", ".", "ProjectID", ",", "Revision", ":", "cs", ".", "Revision", ",", "URL", ":", "cs", ".", "ViewURL", ",", "}", "\n", "parentKey", ":=", "datastore", ".", "KeyForObj", "(", "c", ",", "project", ")", "\n\n", "toSave", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "1", "+", "len", "(", "cs", ".", "ProjectConfig", ".", "Notifiers", ")", "+", "len", "(", "cs", ".", "EmailTemplates", ")", ")", "\n", "toSave", "=", "append", "(", "toSave", ",", "project", ")", "\n\n", "// Collect the list of builders we want to update or create.", "liveBuilders", ":=", "stringset", ".", "New", "(", "len", "(", "cs", ".", "ProjectConfig", ".", "Notifiers", ")", ")", "\n", "builders", ":=", "make", "(", "[", "]", "*", "Builder", ",", "0", ",", "len", "(", "cs", ".", "ProjectConfig", ".", "Notifiers", ")", ")", "\n", "for", "_", ",", "cfgNotifier", ":=", "range", "cs", ".", "ProjectConfig", ".", "Notifiers", "{", "for", "_", ",", "cfgBuilder", ":=", "range", "cfgNotifier", ".", "Builders", "{", "id", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cfgBuilder", ".", "Bucket", ",", "cfgBuilder", ".", "Name", ")", "\n", "builders", "=", "append", "(", "builders", ",", "&", "Builder", "{", "ProjectKey", ":", "parentKey", ",", "ID", ":", "id", ",", "}", ")", "\n", "liveBuilders", ".", "Add", "(", "id", ")", "\n", "}", "\n", "}", "\n\n", "// Lookup the builders in the datastore, if they're not found that's OK since", "// there could be new builders being initialized.", "datastore", ".", "Get", "(", "c", ",", "builders", ")", "\n\n", "i", ":=", "0", "\n", "for", "_", ",", "cfgNotifier", ":=", "range", "cs", ".", "ProjectConfig", ".", "Notifiers", "{", "for", "_", ",", "cfgBuilder", ":=", "range", "cfgNotifier", ".", "Builders", "{", "builders", "[", "i", "]", ".", "Repository", "=", "cfgBuilder", ".", "Repository", "\n", "builders", "[", "i", "]", ".", "Notifications", "=", "notifypb", ".", "Notifications", "{", "Notifications", ":", "cfgNotifier", ".", "Notifications", ",", "}", "\n", "toSave", "=", "append", "(", "toSave", ",", "builders", "[", "i", "]", ")", "\n", "i", "++", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "et", ":=", "range", "cs", ".", "EmailTemplates", "{", "et", ".", "ProjectKey", "=", "parentKey", "\n", "toSave", "=", "append", "(", "toSave", ",", "et", ")", "\n", "}", "\n\n", "return", "parallel", ".", "FanOutIn", "(", "func", "(", "work", "chan", "<-", "func", "(", ")", "error", ")", "{", "work", "<-", "func", "(", ")", "error", "{", "return", "datastore", ".", "Put", "(", "c", ",", "toSave", ")", "\n", "}", "\n", "work", "<-", "func", "(", ")", "error", "{", "return", "removeDescendants", "(", "c", ",", "\"", "\"", ",", "parentKey", ",", "liveBuilders", ".", "Has", ")", "\n", "}", "\n", "work", "<-", "func", "(", ")", "error", "{", "return", "removeDescendants", "(", "c", ",", "\"", "\"", ",", "parentKey", ",", "func", "(", "name", "string", ")", "bool", "{", "_", ",", "ok", ":=", "cs", ".", "EmailTemplates", "[", "name", "]", "\n", "return", "ok", "\n", "}", ")", "\n", "}", "\n", "}", ")", "\n", "}", ",", "nil", ")", "\n", "}" ]

[ "updateProject", "updates", "all", "relevant", "entities", "corresponding", "to", "a", "particular", "project", "in", "a", "single", "datastore", "transaction", ".", "Returns", "the", "set", "of", "notifiers", "that", "were", "updated", "." ]

[ "func", "clearDeadProjects", "(", "c", "context", ".", "Context", ",", "liveProjects", "stringset", ".", "Set", ")", "error", "{", "var", "allProjects", "[", "]", "*", "Project", "\n", "projectQ", ":=", "datastore", ".", "NewQuery", "(", "\"", "\"", ")", ".", "KeysOnly", "(", "true", ")", "\n", "if", "err", ":=", "datastore", ".", "GetAll", "(", "c", ",", "projectQ", ",", "&", "allProjects", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "parallel", ".", "WorkPool", "(", "10", ",", "func", "(", "work", "chan", "<-", "func", "(", ")", "error", ")", "{", "for", "_", ",", "p", ":=", "range", "allProjects", "{", "p", ":=", "p", "\n", "if", "!", "liveProjects", ".", "Has", "(", "p", ".", "Name", ")", "{", "work", "<-", "func", "(", ")", "error", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "p", ".", "Name", ")", "\n", "return", "deleteProject", "(", "c", ",", "p", ".", "Name", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "clearDeadProjects", "calls", "deleteProject", "for", "all", "projects", "in", "the", "datastore", "that", "are", "not", "in", "liveProjects", "." ]

[ "func", "deleteProject", "(", "c", "context", ".", "Context", ",", "projectId", "string", ")", "error", "{", "return", "datastore", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "project", ":=", "&", "Project", "{", "Name", ":", "projectId", "}", "\n", "ancestorKey", ":=", "datastore", ".", "KeyForObj", "(", "c", ",", "project", ")", "\n", "return", "parallel", ".", "FanOutIn", "(", "func", "(", "work", "chan", "<-", "func", "(", ")", "error", ")", "{", "work", "<-", "func", "(", ")", "error", "{", "return", "removeDescendants", "(", "c", ",", "\"", "\"", ",", "ancestorKey", ",", "nil", ")", "\n", "}", "\n", "work", "<-", "func", "(", ")", "error", "{", "return", "removeDescendants", "(", "c", ",", "\"", "\"", ",", "ancestorKey", ",", "nil", ")", "\n", "}", "\n", "work", "<-", "func", "(", ")", "error", "{", "return", "datastore", ".", "Delete", "(", "c", ",", "project", ")", "\n", "}", "\n", "}", ")", "\n", "}", ",", "nil", ")", "\n", "}" ]

[ "deleteProject", "deletes", "a", "Project", "entity", "and", "all", "of", "its", "descendants", "." ]

[ "func", "updateProjects", "(", "c", "context", ".", "Context", ")", "error", "{", "cfgName", ":=", "info", ".", "AppID", "(", "c", ")", "+", "\"", "\"", "\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "cfgName", ")", "\n", "lucicfg", ":=", "GetConfigService", "(", "c", ")", "\n", "configs", ",", "err", ":=", "lucicfg", ".", "GetProjectConfigs", "(", "c", ",", "cfgName", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "len", "(", "configs", ")", ")", "\n\n", "// Load revisions of the existing projects from Datastore.", "projectRevisions", ":=", "map", "[", "string", "]", "string", "{", "}", "// project id -> revision", "\n", "err", "=", "datastore", ".", "Run", "(", "c", ",", "datastore", ".", "NewQuery", "(", "\"", "\"", ")", ",", "func", "(", "p", "*", "Project", ")", "error", "{", "projectRevisions", "[", "p", ".", "Name", "]", "=", "p", ".", "Revision", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Update each project concurrently.", "err", "=", "parallel", ".", "WorkPool", "(", "10", ",", "func", "(", "work", "chan", "<-", "func", "(", ")", "error", ")", "{", "for", "_", ",", "cfg", ":=", "range", "configs", "{", "cfg", ":=", "cfg", "\n\n", "curRev", ",", "ok", ":=", "projectRevisions", "[", "cfg", ".", "ConfigSet", ".", "Project", "(", ")", "]", "\n", "if", "ok", "&&", "curRev", "==", "cfg", ".", "Revision", "{", "// Same revision.", "continue", "\n", "}", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "cfg", ".", "ConfigSet", ".", "Project", "(", ")", ",", "curRev", ",", "cfg", ".", "Revision", ")", "\n\n", "work", "<-", "func", "(", ")", "error", "{", "projectId", ":=", "cfg", ".", "ConfigSet", ".", "Project", "(", ")", "\n", "project", ":=", "&", "notifypb", ".", "ProjectConfig", "{", "}", "\n", "if", "err", ":=", "proto", ".", "UnmarshalText", "(", "cfg", ".", "Content", ",", "project", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "ctx", ":=", "&", "validation", ".", "Context", "{", "Context", ":", "c", "}", "\n", "ctx", ".", "SetFile", "(", "cfgName", ")", "\n", "validateProjectConfig", "(", "ctx", ",", "project", ")", "\n", "if", "err", ":=", "ctx", ".", "Finalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "emailTemplates", ",", "err", ":=", "fetchAllEmailTemplates", "(", "c", ",", "lucicfg", ",", "projectId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "parsedConfigSet", ":=", "&", "parsedProjectConfigSet", "{", "ProjectID", ":", "projectId", ",", "ProjectConfig", ":", "project", ",", "EmailTemplates", ":", "emailTemplates", ",", "Revision", ":", "cfg", ".", "Revision", ",", "ViewURL", ":", "cfg", ".", "ViewURL", ",", "}", "\n", "if", "err", ":=", "updateProject", "(", "c", ",", "parsedConfigSet", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "projectId", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Live projects includes both valid and invalid configurations, as long as", "// they are found via luci-config. Otherwise, a minor mistake in a", "// configuration can cause projects to be deleted.", "liveProjects", ":=", "stringset", ".", "New", "(", "0", ")", "\n", "for", "_", ",", "cfg", ":=", "range", "configs", "{", "liveProjects", ".", "Add", "(", "cfg", ".", "ConfigSet", ".", "Project", "(", ")", ")", "\n", "}", "\n", "return", "clearDeadProjects", "(", "c", ",", "liveProjects", ")", "\n", "}" ]

[ "updateProjects", "updates", "all", "Projects", "and", "their", "Notifiers", "in", "the", "datastore", "." ]

[ "func", "WithConfigService", "(", "c", "context", ".", "Context", ",", "cInterface", "configInterface", ".", "Interface", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "&", "configInterfaceKey", ",", "cInterface", ")", "\n", "}" ]

[ "WithConfigService", "sets", "a", "luci_notify", "config", "interface", "to", "be", "used", "for", "all", "config", "interaction", "." ]

[ "func", "GetConfigService", "(", "c", "context", ".", "Context", ")", "configInterface", ".", "Interface", "{", "if", "iface", ",", "ok", ":=", "c", ".", "Value", "(", "&", "configInterfaceKey", ")", ".", "(", "configInterface", ".", "Interface", ")", ";", "ok", "{", "return", "iface", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetConfigService", "returns", "an", "Inteface", "based", "on", "the", "provided", "context", "values" ]

[ "func", "UpdateHandler", "(", "ctx", "*", "router", ".", "Context", ")", "{", "c", ",", "h", ":=", "ctx", ".", "Context", ",", "ctx", ".", "Writer", "\n", "c", ",", "_", "=", "context", ".", "WithTimeout", "(", "c", ",", "time", ".", "Minute", ")", "\n", "if", "err", ":=", "updateProjects", "(", "c", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "h", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "return", "\n", "}", "\n", "if", "err", ":=", "updateSettings", "(", "c", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "h", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "return", "\n", "}", "\n", "h", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "}" ]

[ "UpdateHandler", "is", "the", "HTTP", "router", "handler", "for", "handling", "cron", "-", "triggered", "configuration", "update", "requests", "." ]

[ "func", "removeDescendants", "(", "c", "context", ".", "Context", ",", "kind", "string", ",", "ancestor", "*", "datastore", ".", "Key", ",", "preserve", "func", "(", "string", ")", "bool", ")", "error", "{", "var", "toDelete", "[", "]", "*", "datastore", ".", "Key", "\n", "q", ":=", "datastore", ".", "NewQuery", "(", "kind", ")", ".", "Ancestor", "(", "ancestor", ")", ".", "KeysOnly", "(", "true", ")", "\n", "err", ":=", "datastore", ".", "Run", "(", "c", ",", "q", ",", "func", "(", "key", "*", "datastore", ".", "Key", ")", "error", "{", "id", ":=", "key", ".", "StringID", "(", ")", "\n", "if", "preserve", "!=", "nil", "&&", "preserve", "(", "id", ")", "{", "return", "nil", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "key", ".", "String", "(", ")", ")", "\n", "toDelete", "=", "append", "(", "toDelete", ",", "key", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "datastore", ".", "Delete", "(", "c", ",", "toDelete", ")", "\n", "}" ]

[ "removeDescedants", "deletes", "all", "entities", "of", "a", "given", "kind", "under", "the", "ancestor", ".", "If", "preserve", "is", "not", "nil", "and", "it", "returns", "true", "for", "a", "string", "id", "the", "entity", "is", "not", "deleted", "." ]

[ "func", "NewUploader", "(", "ctx", "context", ".", "Context", ",", "client", "*", "isolatedclient", ".", "Client", ",", "maxConcurrent", "int", ")", "*", "ConcurrentUploader", "{", "return", "newUploader", "(", "ctx", ",", "client", ",", "maxConcurrent", ")", "\n", "}" ]

[ "NewUploader", "creates", "a", "new", "ConcurrentUploader", "with", "the", "given", "isolated", "client", ".", "maxConcurrent", "controls", "maximum", "number", "of", "uploads", "to", "be", "in", "-", "flight", "at", "once", ".", "The", "provided", "context", "is", "used", "to", "make", "all", "requests", "to", "the", "isolate", "server", "." ]

[ "func", "config", "(", "c", "context", ".", "Context", ")", "*", "Config", "{", "cfg", ",", "_", ":=", "c", ".", "Value", "(", "configContextKey", "(", "0", ")", ")", ".", "(", "*", "Config", ")", "\n", "if", "cfg", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "cfg", "\n", "}" ]

[ "config", "returns", "Config", "passed", "to", "InstallHandlers", "." ]

[ "func", "startTime", "(", "c", "context", ".", "Context", ")", "time", ".", "Time", "{", "ts", ",", "ok", ":=", "c", ".", "Value", "(", "startTimeContextKey", "(", "0", ")", ")", ".", "(", "time", ".", "Time", ")", "\n", "if", "!", "ok", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "ts", "\n", "}" ]

[ "startTime", "returns", "timestamp", "when", "we", "started", "handling", "the", "request", "." ]

[ "func", "(", "l", "*", "logdogServer", ")", "ExportIntoEnv", "(", "env", "environ", ".", "Env", ")", "error", "{", "if", "l", ".", "serv", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "(", "&", "bootstrap", ".", "Environment", "{", "CoordinatorHost", ":", "l", ".", "CoordinatorHost", ",", "Project", ":", "l", ".", "Project", ",", "Prefix", ":", "l", ".", "Prefix", ",", "StreamServerURI", ":", "l", ".", "serv", ".", "Address", "(", ")", ",", "}", ")", ".", "Augment", "(", "env", ")", "\n", "return", "nil", "\n", "}" ]

[ "ExportIntoEnv", "modifies", "env", "to", "export", "location", "of", "this", "local", "LogDog", "server", "into", "the", "environment", "so", "a", "subprocesses", "can", "stream", "logs", "." ]

[ "func", "(", "l", "*", "logdogServer", ")", "AddStream", "(", "rc", "io", ".", "ReadCloser", ",", "props", "*", "streamproto", ".", "Properties", ")", "error", "{", "return", "l", ".", "butler", ".", "AddStream", "(", "rc", ",", "props", ")", "\n", "}" ]

[ "AddStream", "adds", "a", "new", "stream", ".", "If", "no", "error", "is", "returned", "the", "logdogServ", "assumes", "ownership", "of", "the", "supplied", "stream", ".", "The", "stream", "will", "be", "closed", "when", "processing", "is", "finished", "." ]

[ "func", "(", "l", "*", "logdogServer", ")", "Stop", "(", ")", "error", "{", "if", "l", ".", "serv", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "l", ".", "butler", ".", "Activate", "(", ")", "\n", "if", "err", ":=", "l", ".", "butler", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "l", ".", "output", ".", "Close", "(", ")", "\n\n", "l", ".", "serv", "=", "nil", "\n", "l", ".", "output", "=", "nil", "\n", "l", ".", "butler", "=", "nil", "\n", "return", "nil", "\n", "}" ]

[ "Stop", "stops", "the", "server", "." ]

[ "func", "disableGRPCLogging", "(", "ctx", "context", ".", "Context", ")", "{", "level", ":=", "logging", ".", "Debug", "\n", "if", "!", "logging", ".", "IsLogging", "(", "ctx", ",", "logging", ".", "Debug", ")", "{", "level", "=", "grpcLogging", ".", "Suppress", "\n", "}", "\n", "grpcLogging", ".", "Install", "(", "logging", ".", "Get", "(", "ctx", ")", ",", "level", ")", "\n", "}" ]

[ "disableGRPCLogging", "routes", "gRPC", "log", "messages", "that", "are", "emitted", "through", "our", "logger", ".", "We", "only", "log", "gRPC", "prints", "if", "our", "logger", "is", "configured", "to", "log", "debug", "-", "level", "or", "lower", "which", "it", "isn", "t", "by", "default", "." ]

[ "func", "(", "s", "Subscription", ")", "SplitErr", "(", ")", "(", "p", ",", "n", "string", ",", "err", "error", ")", "{", "p", ",", "n", ",", "err", "=", "resourceProjectName", "(", "string", "(", "s", ")", ")", "\n", "return", "\n", "}" ]

[ "SplitErr", "returns", "the", "Subscription", "s", "project", "and", "name", "components", "." ]

[ "func", "Use", "(", "c", "context", ".", "Context", ",", "s", "*", "Settings", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "contextKey", "(", "0", ")", ",", "s", ")", "\n", "}" ]

[ "Use", "injects", "Settings", "into", "the", "context", "to", "be", "used", "by", "Get", "and", "Set", "." ]

[ "func", "GetSettings", "(", "c", "context", ".", "Context", ")", "*", "Settings", "{", "if", "s", ",", "ok", ":=", "c", ".", "Value", "(", "contextKey", "(", "0", ")", ")", ".", "(", "*", "Settings", ")", ";", "ok", "&&", "s", "!=", "nil", "{", "return", "s", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetSettings", "grabs", "Settings", "from", "the", "context", "if", "it", "s", "there", "." ]

[ "func", "printSwitches", "(", "tsv", "bool", ",", "switches", "...", "*", "crimson", ".", "Switch", ")", "{", "if", "len", "(", "switches", ")", ">", "0", "{", "p", ":=", "newStdoutPrinter", "(", "tsv", ")", "\n", "defer", "p", ".", "Flush", "(", ")", "\n", "if", "!", "tsv", "{", "p", ".", "Row", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "s", ":=", "range", "switches", "{", "p", ".", "Row", "(", "s", ".", "Name", ",", "s", ".", "Ports", ",", "s", ".", "Rack", ",", "s", ".", "Datacenter", ",", "s", ".", "Description", ",", "s", ".", "State", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "printSwitches", "prints", "switch", "data", "to", "stdout", "in", "tab", "-", "separated", "columns", "." ]

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

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

[ "func", "getSwitchesCmd", "(", "params", "*", "Parameters", ")", "*", "subcommands", ".", "Command", "{", "return", "&", "subcommands", ".", "Command", "{", "UsageLine", ":", "\"", "\"", ",", "ShortDesc", ":", "\"", "\"", ",", "LongDesc", ":", "\"", "\\n", "\\n", "\\n", "\\n", "\\n", "\"", ",", "CommandRun", ":", "func", "(", ")", "subcommands", ".", "CommandRun", "{", "cmd", ":=", "&", "GetSwitchesCmd", "{", "}", "\n", "cmd", ".", "Initialize", "(", "params", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "req", ".", "Names", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "req", ".", "Racks", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "req", ".", "Datacenters", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}", ",", "}", "\n", "}" ]

[ "getSwitchesCmd", "returns", "a", "command", "to", "get", "switches", "." ]

[ "func", "NewNamedPipeServer", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "StreamServer", ",", "error", ")", "{", "switch", "l", ":=", "len", "(", "name", ")", ";", "{", "case", "l", "==", "0", ":", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "l", ">", "maxWindowsNamedPipeLength", ":", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ",", "maxWindowsNamedPipeLength", ")", ".", "InternalReason", "(", "\"", "\"", ",", "name", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "ctx", "=", "log", ".", "SetField", "(", "ctx", ",", "\"", "\"", ",", "name", ")", "\n", "return", "&", "listenerStreamServer", "{", "Context", ":", "ctx", ",", "gen", ":", "func", "(", ")", "(", "net", ".", "Listener", ",", "string", ",", "error", ")", "{", "address", ":=", "\"", "\"", "+", "name", "\n", "pipePath", ":=", "streamclient", ".", "LocalNamedPipePath", "(", "name", ")", "\n", "log", ".", "Fields", "{", "\"", "\"", ":", "address", ",", "\"", "\"", ":", "pipePath", ",", "}", ".", "Debugf", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "l", ",", "err", ":=", "winio", ".", "ListenPipe", "(", "pipePath", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "l", ",", "address", ",", "nil", "\n", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "NewNamedPipeServer", "instantiates", "a", "new", "Windows", "named", "pipe", "server", "instance", "." ]

[ "func", "IsAdminUser", "(", "c", "context", ".", "Context", ")", "error", "{", "cfg", ",", "err", ":=", "GetConfigProvider", "(", "c", ")", ".", "Config", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "checkMember", "(", "c", ",", "cfg", ".", "Coordinator", ".", "AdminAuthGroup", ")", "\n", "}" ]

[ "IsAdminUser", "tests", "whether", "the", "current", "user", "belongs", "to", "the", "administrative", "users", "group", ".", "If", "the", "user", "is", "not", "a", "MembershipError", "will", "be", "returned", "." ]

[ "func", "IsServiceUser", "(", "c", "context", ".", "Context", ")", "error", "{", "cfg", ",", "err", ":=", "GetConfigProvider", "(", "c", ")", ".", "Config", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "checkMember", "(", "c", ",", "cfg", ".", "Coordinator", ".", "ServiceAuthGroup", ")", "\n", "}" ]

[ "IsServiceUser", "tests", "whether", "the", "current", "user", "belongs", "to", "the", "backend", "services", "users", "group", ".", "If", "the", "user", "is", "not", "a", "MembershipError", "will", "be", "returned", "." ]

[ "func", "IsProjectReader", "(", "c", "context", ".", "Context", ",", "pcfg", "*", "svcconfig", ".", "ProjectConfig", ")", "error", "{", "return", "checkMember", "(", "c", ",", "pcfg", ".", "ReaderAuthGroups", "...", ")", "\n", "}" ]

[ "IsProjectReader", "tests", "whether", "the", "current", "user", "belongs", "to", "one", "of", "the", "project", "s", "declared", "reader", "groups", ".", "If", "the", "user", "is", "not", "a", "MembershipError", "will", "be", "returned", "." ]

[ "func", "IsProjectWriter", "(", "c", "context", ".", "Context", ",", "pcfg", "*", "svcconfig", ".", "ProjectConfig", ")", "error", "{", "return", "checkMember", "(", "c", ",", "pcfg", ".", "WriterAuthGroups", "...", ")", "\n", "}" ]

[ "IsProjectWriter", "tests", "whether", "the", "current", "user", "belongs", "to", "one", "of", "the", "project", "s", "declared", "writer", "groups", ".", "If", "the", "user", "is", "not", "a", "member", "of", "any", "of", "the", "groups", "a", "MembershipError", "will", "be", "returned", "." ]

[ "func", "(", "lc", "*", "LimitedClient", ")", "NewReader", "(", "p", "Path", ",", "offset", ",", "length", "int64", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "if", "lc", ".", "MaxReadBytes", "<=", "0", "||", "(", "length", ">", "0", "&&", "length", "<=", "lc", ".", "MaxReadBytes", ")", "{", "return", "lc", ".", "Client", ".", "NewReader", "(", "p", ",", "offset", ",", "length", ")", "\n", "}", "\n\n", "lr", ":=", "limitedReader", "{", "lc", ":", "lc", ",", "path", ":", "p", ",", "maxReadBytes", ":", "lc", ".", "MaxReadBytes", ",", "nextOffset", ":", "offset", ",", "nextLength", ":", "length", ",", "}", "\n", "if", "err", ":=", "lr", ".", "nextReader", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "lr", ",", "nil", "\n", "}" ]

[ "NewReader", "implements", "Client", "." ]

[ "func", "NewFlags", "(", ")", "Flags", "{", "return", "Flags", "{", "TargetType", ":", "DeviceType", ",", "DeviceHostname", ":", "\"", "\"", ",", "DeviceRegion", ":", "\"", "\"", ",", "DeviceRole", ":", "\"", "\"", ",", "DeviceNetwork", ":", "\"", "\"", ",", "TaskServiceName", ":", "\"", "\"", ",", "TaskJobName", ":", "\"", "\"", ",", "TaskRegion", ":", "\"", "\"", ",", "TaskHostname", ":", "\"", "\"", ",", "TaskNumber", ":", "0", ",", "AutoGenHostname", ":", "false", ",", "}", "\n", "}" ]

[ "NewFlags", "returns", "a", "Flags", "struct", "with", "sensible", "default", "values", ".", "Hostname", "region", "and", "network", "flags", "are", "expensive", "to", "compute", "so", "get", "assigned", "default", "values", "later", "in", "SetDefaultsFromHostname", "." ]

[ "func", "(", "fl", "*", "Flags", ")", "SetDefaultsFromHostname", "(", ")", "{", "if", "fl", ".", "SysInfo", "==", "nil", "{", "hostname", ",", "region", ":=", "getFQDN", "(", ")", "\n", "fl", ".", "SysInfo", "=", "&", "SysInfo", "{", "Hostname", ":", "hostname", ",", "Region", ":", "region", "}", "\n", "}", "\n", "network", ":=", "getNetwork", "(", "fl", ".", "SysInfo", ".", "Hostname", ")", "\n", "hostname", ":=", "fl", ".", "SysInfo", ".", "Hostname", "\n\n", "if", "fl", ".", "DeviceHostname", "==", "\"", "\"", "{", "fl", ".", "DeviceHostname", "=", "hostname", "\n", "}", "\n", "if", "fl", ".", "DeviceRegion", "==", "\"", "\"", "{", "fl", ".", "DeviceRegion", "=", "fl", ".", "SysInfo", ".", "Region", "\n", "}", "\n", "if", "fl", ".", "DeviceNetwork", "==", "\"", "\"", "{", "fl", ".", "DeviceNetwork", "=", "network", "\n", "}", "\n", "if", "fl", ".", "TaskRegion", "==", "\"", "\"", "{", "fl", ".", "TaskRegion", "=", "fl", ".", "SysInfo", ".", "Region", "\n", "}", "\n", "if", "fl", ".", "TaskHostname", "==", "\"", "\"", "{", "fl", ".", "TaskHostname", "=", "hostname", "\n", "}", "\n", "if", "fl", ".", "AutoGenHostname", "{", "fl", ".", "DeviceHostname", "=", "\"", "\"", "+", "fl", ".", "DeviceHostname", "\n", "fl", ".", "TaskHostname", "=", "\"", "\"", "+", "fl", ".", "TaskHostname", "\n", "}", "\n", "}" ]

[ "SetDefaultsFromHostname", "computes", "the", "expensive", "default", "values", "for", "hostname", "region", "and", "network", "fields", "." ]

[ "func", "(", "fl", "*", "Flags", ")", "Register", "(", "f", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "Var", "(", "&", "fl", ".", "TargetType", ",", "\"", "\"", ",", "\"", "\"", "+", "targetTypeEnum", ".", "Choices", "(", ")", "+", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "DeviceHostname", ",", "\"", "\"", ",", "fl", ".", "DeviceHostname", ",", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "DeviceRegion", ",", "\"", "\"", ",", "fl", ".", "DeviceRegion", ",", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "DeviceRole", ",", "\"", "\"", ",", "fl", ".", "DeviceRole", ",", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "DeviceNetwork", ",", "\"", "\"", ",", "fl", ".", "DeviceNetwork", ",", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "TaskServiceName", ",", "\"", "\"", ",", "fl", ".", "TaskServiceName", ",", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "TaskJobName", ",", "\"", "\"", ",", "fl", ".", "TaskJobName", ",", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "TaskRegion", ",", "\"", "\"", ",", "fl", ".", "TaskRegion", ",", "\"", "\"", ")", "\n", "f", ".", "StringVar", "(", "&", "fl", ".", "TaskHostname", ",", "\"", "\"", ",", "fl", ".", "TaskHostname", ",", "\"", "\"", ")", "\n", "f", ".", "IntVar", "(", "&", "fl", ".", "TaskNumber", ",", "\"", "\"", ",", "fl", ".", "TaskNumber", ",", "\"", "\"", ")", "\n", "f", ".", "BoolVar", "(", "&", "fl", ".", "AutoGenHostname", ",", "\"", "\"", ",", "fl", ".", "AutoGenHostname", ",", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ")", "\n", "}" ]

[ "Register", "adds", "tsmon", "target", "related", "flags", "to", "a", "FlagSet", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "EnqueueTask", "(", "c", "context", ".", "Context", ",", "tsk", "*", "tq", ".", "Task", ")", "error", "{", "tsk", ".", "Path", "=", "handlerPath", "(", "cfg", ".", "Name", ")", "\n", "return", "tq", ".", "Add", "(", "c", ",", "\"", "\"", ",", "tsk", ")", "\n", "}" ]

[ "EnqueueTask", "allows", "a", "Distributor", "to", "enqueue", "a", "TaskQueue", "task", "that", "will", "be", "handled", "by", "the", "Distributor", "s", "HandleTaskQueueTask", "method", "." ]

[ "func", "(", "cfg", "*", "Config", ")", "PrepareTopic", "(", "c", "context", ".", "Context", ",", "eid", "*", "dm", ".", "Execution_ID", ")", "(", "topic", "pubsub", ".", "Topic", ",", "token", "string", ",", "err", "error", ")", "{", "topic", "=", "pubsub", ".", "NewTopic", "(", "info", ".", "TrimmedAppID", "(", "c", ")", ",", "notifyTopicSuffix", ")", "\n", "if", "err", ":=", "topic", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "topic", ",", "err", ")", ")", "\n", "}", "\n", "token", ",", "err", "=", "encodeAuthToken", "(", "c", ",", "eid", ",", "cfg", ".", "Name", ")", "\n", "return", "\n", "}" ]

[ "PrepareTopic", "returns", "a", "pubsub", "topic", "that", "notifications", "should", "be", "sent", "to", "and", "is", "meant", "to", "be", "called", "from", "the", "D", ".", "Run", "method", ".", "It", "returns", "the", "full", "name", "of", "the", "topic", "and", "a", "token", "that", "will", "be", "used", "to", "route", "PubSub", "messages", "back", "to", "the", "Distributor", ".", "The", "publisher", "to", "the", "topic", "must", "be", "instructed", "to", "put", "the", "token", "into", "the", "auth_token", "attribute", "of", "PubSub", "messages", ".", "DM", "will", "know", "how", "to", "route", "such", "messages", "to", "D", ".", "HandleNotification", "." ]

[ "func", "CaptureStacktrace", "(", "th", "*", "starlark", ".", "Thread", ",", "skip", "int", ")", "(", "*", "CapturedStacktrace", ",", "error", ")", "{", "f", ":=", "th", ".", "Caller", "(", ")", "\n", "skipped", ":=", "0", "\n", "for", "skipped", "<", "skip", "&&", "f", "!=", "nil", "{", "f", "=", "f", ".", "Parent", "(", ")", "\n", "skipped", "++", "\n", "}", "\n", "if", "f", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "skip", ",", "skipped", ")", "\n", "}", "\n", "buf", ":=", "strings", ".", "Builder", "{", "}", "\n", "f", ".", "WriteBacktrace", "(", "&", "buf", ")", "\n", "return", "&", "CapturedStacktrace", "{", "buf", ".", "String", "(", ")", "}", ",", "nil", "\n", "}" ]

[ "CaptureStacktrace", "captures", "thread", "s", "stack", "trace", "skipping", "some", "number", "of", "innermost", "frames", ".", "Returns", "an", "error", "if", "the", "stack", "is", "not", "deep", "enough", "to", "skip", "the", "requested", "number", "of", "frames", "." ]

[ "func", "(", "c", "*", "Strings", ")", "Set", "(", "value", "string", ")", "error", "{", "*", "c", "=", "append", "(", "*", "c", ",", "value", ")", "\n", "return", "nil", "\n", "}" ]

[ "Set", "is", "needed", "to", "implements", "flag", ".", "Var", "interface", "." ]

[ "func", "(", "ac", "*", "Context", ")", "Launch", "(", "ctx", "context", ".", "Context", ",", "tempDir", "string", ")", "(", "nc", "context", ".", "Context", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "ac", ".", "Close", "(", ")", "\n", "}", "\n", "nc", "=", "ac", ".", "ctx", "// nil if err != nil", "\n", "}", "(", ")", "\n\n", "ac", ".", "ctx", "=", "ctx", "\n\n", "if", "tempDir", "==", "\"", "\"", "{", "ac", ".", "tmpDir", ",", "err", "=", "ioutil", ".", "TempDir", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "tempDir", "=", "ac", ".", "tmpDir", "\n", "}", "\n\n", "// Expand AuthSelectMethod into the actual method. We'll be checking it later.", "// We do this expansion now to consistently use new 'opts' through out.", "opts", ":=", "ac", ".", "Options", "\n", "if", "opts", ".", "Method", "==", "auth", ".", "AutoSelectMethod", "{", "opts", ".", "Method", "=", "auth", ".", "SelectBestMethod", "(", "ac", ".", "ctx", ",", "opts", ")", "\n", "}", "\n\n", "// Construct the authenticator to be used directly by the helpers hosted in", "// the current process (devshell, gsutil, firebase) and by the new", "// localauth.Server (if we are going to launch it). Out-of-process helpers", "// (git, docker) will use LUCI_CONTEXT protocol.", "ac", ".", "authenticator", "=", "auth", ".", "NewAuthenticator", "(", "ac", ".", "ctx", ",", "auth", ".", "SilentLogin", ",", "opts", ")", "\n\n", "// Figure out what email is associated with this account (if any).", "ac", ".", "email", ",", "err", "=", "ac", ".", "authenticator", ".", "GetEmail", "(", ")", "\n", "switch", "{", "case", "err", "==", "auth", ".", "ErrLoginRequired", ":", "// This context is not associated with any account. This happens when", "// running Swarming tasks without service account specified or running", "// locally without doing 'luci-auth login' first.", "ac", ".", "anonymous", "=", "true", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "ac", ".", "ID", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Check whether we are allowed to inherit the existing LUCI_CONTEXT. We do it", "// if 'opts' indicate to use LUCI_CONTEXT and do NOT use impersonation. When", "// impersonating, we must launch a new auth server to actually perform it", "// there.", "//", "// If we can't reuse the existing LUCI_CONTEXT, launch a new one (deriving", "// a new context.Context with it).", "//", "// If there's no auth credentials at all, do not launch any LUCI_CONTEXT (it", "// is impossible without credentials). Subprocesses will discover lack of", "// ambient credentials on their own and fail (or proceed) appropriately.", "canInherit", ":=", "opts", ".", "Method", "==", "auth", ".", "LUCIContextMethod", "&&", "opts", ".", "ActAsServiceAccount", "==", "\"", "\"", "\n", "if", "!", "canInherit", "&&", "!", "ac", ".", "anonymous", "{", "var", "la", "*", "lucictx", ".", "LocalAuth", "\n", "if", "ac", ".", "luciSrv", ",", "la", ",", "err", "=", "launchSrv", "(", "ac", ".", "ctx", ",", "opts", ",", "ac", ".", "authenticator", ",", "ac", ".", "ID", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "ac", ".", "ID", ")", ".", "Err", "(", ")", "\n", "}", "\n", "ac", ".", "ctx", "=", "lucictx", ".", "SetLocalAuth", "(", "ac", ".", "ctx", ",", "la", ")", "// switch to new LUCI_CONTEXT", "\n", "}", "\n\n", "// Drop the new LUCI_CONTEXT file to the disk. This is noop when reusing", "// an existing one.", "if", "ac", ".", "exported", ",", "err", "=", "lucictx", ".", "ExportInto", "(", "ac", ".", "ctx", ",", "tempDir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "ac", ".", "ID", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Now setup various credential helpers (they all mutate 'ac' and return", "// annotated errors).", "if", "ac", ".", "EnableGitAuth", "{", "if", "err", ":=", "ac", ".", "setupGitAuth", "(", "tempDir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "ac", ".", "EnableDockerAuth", "{", "if", "err", ":=", "ac", ".", "setupDockerAuth", "(", "tempDir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "ac", ".", "EnableDevShell", "&&", "!", "ac", ".", "anonymous", "{", "if", "err", ":=", "ac", ".", "setupDevShellAuth", "(", "tempDir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "ac", ".", "EnableFirebaseAuth", "&&", "!", "ac", ".", "anonymous", "{", "if", "err", ":=", "ac", ".", "setupFirebaseAuth", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Launch", "launches", "this", "auth", "context", ".", "It", "must", "be", "called", "before", "any", "other", "method", ".", "It", "launches", "various", "local", "server", "and", "prepares", "various", "configs", "by", "putting", "them", "into", "tempDir", "which", "may", "be", "to", "use", "some", "new", "ioutil", ".", "TempDir", ".", "On", "success", "returns", "a", "new", "context", ".", "Context", "with", "updated", "LUCI_CONTEXT", "value", ".", "To", "run", "a", "subprocess", "within", "this", "new", "context", "use", "ExportIntoEnv", "to", "modify", "an", "environ", "for", "a", "new", "process", "." ]

[ "func", "(", "ac", "*", "Context", ")", "ExportIntoEnv", "(", "env", "environ", ".", "Env", ")", "environ", ".", "Env", "{", "env", "=", "env", ".", "Clone", "(", ")", "\n", "ac", ".", "exported", ".", "SetInEnviron", "(", "env", ")", "\n\n", "if", "ac", ".", "EnableGitAuth", "{", "env", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "// no interactive prompts", "\n", "env", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "// no $(prefix)/etc/gitconfig", "\n", "env", ".", "Set", "(", "\"", "\"", ",", "ac", ".", "gitHome", ")", "// tell gitwrapper about the new HOME", "\n", "}", "\n\n", "if", "ac", ".", "EnableDockerAuth", "{", "env", ".", "Set", "(", "\"", "\"", ",", "ac", ".", "dockerConfig", ")", "\n", "env", ".", "Set", "(", "\"", "\"", ",", "ac", ".", "dockerTmpDir", ")", "\n", "}", "\n\n", "if", "ac", ".", "EnableDevShell", "{", "env", ".", "Remove", "(", "\"", "\"", ")", "// avoid picking up bot-local configs, if any", "\n", "if", "ac", ".", "anonymous", "{", "// Make sure gsutil is not picking up any stale .boto configs randomly", "// laying around on the bot. Setting BOTO_CONFIG to empty dir disables", "// default ~/.boto.", "env", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "else", "{", "// Point gsutil to use our auth shim server and export devshell port.", "env", ".", "Set", "(", "\"", "\"", ",", "ac", ".", "gsutilBoto", ")", "\n", "if", "ac", ".", "devShellAddr", "!=", "nil", "{", "env", ".", "Set", "(", "devshell", ".", "EnvKey", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ac", ".", "devShellAddr", ".", "Port", ")", ")", "\n", "}", "else", "{", "// See https://crbug.com/788058#c14.", "logging", ".", "Warningf", "(", "ac", ".", "ctx", ",", "\"", "\"", ",", "ac", ".", "ID", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "ac", ".", "EnableFirebaseAuth", "&&", "!", "ac", ".", "anonymous", "{", "// Point firebase to the generated token.", "env", ".", "Set", "(", "\"", "\"", ",", "ac", ".", "firebaseTokenURL", ")", "\n", "}", "\n\n", "return", "env", "\n", "}" ]

[ "ExportIntoEnv", "exports", "details", "of", "this", "context", "into", "the", "environment", "so", "it", "can", "be", "inherited", "by", "subprocesses", "that", "supports", "it", ".", "Returns", "a", "modified", "copy", "of", "env", "." ]

[ "func", "(", "ac", "*", "Context", ")", "Report", "(", ")", "{", "account", ":=", "ac", ".", "email", "\n", "if", "ac", ".", "anonymous", "{", "account", "=", "\"", "\"", "\n", "}", "\n", "logging", ".", "Infof", "(", "ac", ".", "ctx", ",", "\"", "\"", ",", "ac", ".", "ID", ",", "account", ",", "ac", ".", "EnableGitAuth", ",", "ac", ".", "EnableDevShell", ",", "ac", ".", "EnableDockerAuth", ",", "ac", ".", "EnableFirebaseAuth", ")", "\n", "}" ]

[ "Report", "logs", "the", "service", "account", "email", "used", "by", "this", "auth", "context", "." ]

[ "func", "NewTarringArchiver", "(", "checker", "Checker", ",", "uploader", "Uploader", ")", "*", "TarringArchiver", "{", "return", "&", "TarringArchiver", "{", "checker", ":", "checker", ",", "uploader", ":", "uploader", "}", "\n", "}" ]

[ "NewTarringArchiver", "constructs", "a", "TarringArchiver", "." ]

[ "func", "(", "ta", "*", "TarringArchiver", ")", "Archive", "(", "deps", "[", "]", "string", ",", "rootDir", "string", ",", "isol", "*", "isolated", ".", "Isolated", ",", "blacklist", "[", "]", "string", ",", "isolated", "string", ")", "(", "IsolatedSummary", ",", "error", ")", "{", "parts", ",", "err", ":=", "partitionDeps", "(", "deps", ",", "rootDir", ",", "blacklist", ")", "\n", "if", "err", "!=", "nil", "{", "return", "IsolatedSummary", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "parts", ")", "\n\n", "tracker", ":=", "newUploadTracker", "(", "ta", ".", "checker", ",", "ta", ".", "uploader", ",", "isol", ")", "\n", "if", "err", ":=", "tracker", ".", "UploadDeps", "(", "parts", ")", ";", "err", "!=", "nil", "{", "return", "IsolatedSummary", "{", "}", ",", "err", "\n", "}", "\n", "return", "tracker", ".", "Finalize", "(", "isolated", ")", "\n", "}" ]

[ "Archive", "uploads", "a", "single", "isolate", "." ]

[ "func", "(", "pw", "*", "partitioningWalker", ")", "walkFn", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "relPath", ",", "err", ":=", "pw", ".", "fsView", ".", "RelativePath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "pw", ".", "seen", ".", "Add", "(", "relPath", ")", "||", "relPath", "==", "\"", "\"", "{", "// Either the file or directory was already walked, or empty string", "// indicates skip.", "return", "common", ".", "WalkFuncSkipFile", "(", "info", ")", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "item", ":=", "&", "Item", "{", "Path", ":", "path", ",", "RelPath", ":", "relPath", ",", "Mode", ":", "info", ".", "Mode", "(", ")", ",", "Size", ":", "info", ".", "Size", "(", ")", ",", "}", "\n\n", "switch", "{", "case", "item", ".", "Mode", "&", "os", ".", "ModeSymlink", "==", "os", ".", "ModeSymlink", ":", "pw", ".", "parts", ".", "links", ".", "AddItem", "(", "item", ")", "\n", "case", "item", ".", "Size", "<", "archiveThreshold", ":", "pw", ".", "parts", ".", "filesToArchive", ".", "AddItem", "(", "item", ")", "\n", "default", ":", "pw", ".", "parts", ".", "indivFiles", ".", "AddItem", "(", "item", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "walkFn", "implements", "filepath", ".", "WalkFunc", "for", "use", "traversing", "a", "directory", "hierarchy", "to", "be", "isolated", ".", "It", "accumulates", "files", "in", "pw", ".", "parts", "partitioned", "into", "symlinks", "and", "files", "categorized", "by", "size", "." ]

[ "func", "partitionDeps", "(", "deps", "[", "]", "string", ",", "rootDir", "string", ",", "blacklist", "[", "]", "string", ")", "(", "partitionedDeps", ",", "error", ")", "{", "fsView", ",", "err", ":=", "common", ".", "NewFilesystemView", "(", "rootDir", ",", "blacklist", ")", "\n", "if", "err", "!=", "nil", "{", "return", "partitionedDeps", "{", "}", ",", "err", "\n", "}", "\n\n", "walker", ":=", "partitioningWalker", "{", "fsView", ":", "fsView", ",", "seen", ":", "stringset", ".", "New", "(", "1024", ")", "}", "\n", "for", "_", ",", "dep", ":=", "range", "deps", "{", "// Try to walk dep. If dep is a file (or symlink), the inner function is called exactly once.", "if", "err", ":=", "filepath", ".", "Walk", "(", "filepath", ".", "Clean", "(", "dep", ")", ",", "walker", ".", "walkFn", ")", ";", "err", "!=", "nil", "{", "return", "partitionedDeps", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n", "return", "walker", ".", "parts", ",", "nil", "\n", "}" ]

[ "partitionDeps", "walks", "each", "of", "the", "deps", "partioning", "the", "results", "into", "symlinks", "and", "files", "categorized", "by", "size", "." ]

[ "func", "NewServer", "(", ")", "minter", ".", "TokenMinterServer", "{", "return", "&", "serverImpl", "{", "MintMachineTokenRPC", ":", "machinetoken", ".", "MintMachineTokenRPC", "{", "Signer", ":", "gaesigner", ".", "Signer", "{", "}", ",", "CheckCertificate", ":", "certchecker", ".", "CheckCertificate", ",", "LogToken", ":", "machinetoken", ".", "LogToken", ",", "}", ",", "MintDelegationTokenRPC", ":", "delegation", ".", "MintDelegationTokenRPC", "{", "Signer", ":", "gaesigner", ".", "Signer", "{", "}", ",", "Rules", ":", "delegation", ".", "GlobalRulesCache", ".", "Rules", ",", "LogToken", ":", "delegation", ".", "LogToken", ",", "}", ",", "MintOAuthTokenGrantRPC", ":", "serviceaccounts", ".", "MintOAuthTokenGrantRPC", "{", "Signer", ":", "gaesigner", ".", "Signer", "{", "}", ",", "Rules", ":", "serviceaccounts", ".", "GlobalRulesCache", ".", "Rules", ",", "LogGrant", ":", "serviceaccounts", ".", "LogGrant", ",", "}", ",", "MintOAuthTokenViaGrantRPC", ":", "serviceaccounts", ".", "MintOAuthTokenViaGrantRPC", "{", "Signer", ":", "gaesigner", ".", "Signer", "{", "}", ",", "Rules", ":", "serviceaccounts", ".", "GlobalRulesCache", ".", "Rules", ",", "MintAccessToken", ":", "auth", ".", "MintAccessTokenForServiceAccount", ",", "LogOAuthToken", ":", "serviceaccounts", ".", "LogOAuthToken", ",", "}", ",", "MintProjectTokenRPC", ":", "projectscope", ".", "MintProjectTokenRPC", "{", "Signer", ":", "gaesigner", ".", "Signer", "{", "}", ",", "MintAccessToken", ":", "auth", ".", "MintAccessTokenForServiceAccount", ",", "ProjectIdentities", ":", "projectidentity", ".", "ProjectIdentities", ",", "LogToken", ":", "projectscope", ".", "LogToken", ",", "}", ",", "}", "\n", "}" ]

[ "NewServer", "returns", "prod", "TokenMinterServer", "implementation", ".", "It", "does", "all", "authorization", "checks", "inside", "." ]

[ "func", "(", "*", "Service", ")", "ListDatacenters", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "ListDatacentersRequest", ")", "(", "*", "crimson", ".", "ListDatacentersResponse", ",", "error", ")", "{", "datacenters", ",", "err", ":=", "listDatacenters", "(", "c", ",", "stringset", ".", "NewFromSlice", "(", "req", ".", "Names", "...", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "crimson", ".", "ListDatacentersResponse", "{", "Datacenters", ":", "datacenters", ",", "}", ",", "nil", "\n", "}" ]

[ "ListDatacenters", "handles", "a", "request", "to", "retrieve", "datacenters", "." ]

[ "func", "listDatacenters", "(", "c", "context", ".", "Context", ",", "names", "stringset", ".", "Set", ")", "(", "[", "]", "*", "crimson", ".", "Datacenter", ",", "error", ")", "{", "db", ":=", "database", ".", "Get", "(", "c", ")", "\n", "rows", ",", "err", ":=", "db", ".", "QueryContext", "(", "c", ",", "`\n\t\tSELECT name, description, state\n\t\tFROM datacenters\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "var", "datacenters", "[", "]", "*", "crimson", ".", "Datacenter", "\n", "for", "rows", ".", "Next", "(", ")", "{", "dc", ":=", "&", "crimson", ".", "Datacenter", "{", "}", "\n", "if", "err", "=", "rows", ".", "Scan", "(", "&", "dc", ".", "Name", ",", "&", "dc", ".", "Description", ",", "&", "dc", ".", "State", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "matches", "(", "dc", ".", "Name", ",", "names", ")", "{", "datacenters", "=", "append", "(", "datacenters", ",", "dc", ")", "\n", "}", "\n", "}", "\n", "return", "datacenters", ",", "nil", "\n", "}" ]

[ "listDatacenters", "returns", "a", "slice", "of", "datacenters", "in", "the", "database", "." ]

[ "func", "newRuleImpl", "(", "impl", "starlark", ".", "Callable", ",", "defaults", "*", "starlark", ".", "Dict", ")", "(", "*", "ruleImpl", ",", "error", ")", "{", "pairs", ":=", "defaults", ".", "Items", "(", ")", "\n", "for", "_", ",", "pair", ":=", "range", "pairs", "{", "k", ",", "v", ":=", "pair", "[", "0", "]", ",", "pair", "[", "1", "]", "\n", "if", "_", ",", "ok", ":=", "k", ".", "(", "starlark", ".", "String", ")", ";", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ")", "\n", "}", "\n", "if", "!", "isNamedStruct", "(", "v", ",", "\"", "\"", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "&", "ruleImpl", "{", "Callable", ":", "impl", ",", "defaults", ":", "starlarkstruct", ".", "FromKeywords", "(", "starlark", ".", "String", "(", "\"", "\"", ")", ",", "pairs", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "newRuleImpl", "construct", "a", "new", "rule", "if", "arguments", "pass", "the", "validation", "." ]

[ "func", "(", "r", "*", "ruleImpl", ")", "String", "(", ")", "string", "{", "name", ":=", "r", ".", "Callable", ".", "Name", "(", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "TrimPrefix", "(", "name", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "String", "lets", "caller", "know", "this", "is", "a", "rule", "now", "." ]

[ "func", "(", "r", "*", "ruleImpl", ")", "Attr", "(", "name", "string", ")", "(", "starlark", ".", "Value", ",", "error", ")", "{", "switch", "name", "{", "case", "\"", "\"", ":", "return", "r", ".", "defaults", ",", "nil", "\n", "default", ":", "return", "nil", ",", "nil", "\n", "}", "\n", "}" ]

[ "Attr", "is", "part", "of", "starlark", ".", "HasAttrs", "interface", "." ]

[ "func", "(", "s", "*", "persistentStorage", ")", "lookup", "(", "c", "context", ".", "Context", ",", "identity", "*", "ProjectIdentity", ")", "(", "*", "ProjectIdentity", ",", "error", ")", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "identity", ")", "\n", "tmp", ":=", "*", "identity", "\n", "if", "err", ":=", "ds", ".", "Get", "(", "c", ",", "&", "tmp", ")", ";", "err", "!=", "nil", "{", "switch", "{", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "return", "nil", ",", "ErrNotFound", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "&", "tmp", ",", "nil", "\n", "}" ]

[ "lookup", "reads", "an", "identity", "from", "the", "storage", "based", "on", "what", "fields", "are", "set", "in", "the", "identity", "struct", "." ]

[ "func", "(", "s", "*", "persistentStorage", ")", "LookupByProject", "(", "c", "context", ".", "Context", ",", "project", "string", ")", "(", "*", "ProjectIdentity", ",", "error", ")", "{", "return", "s", ".", "lookup", "(", "c", ",", "&", "ProjectIdentity", "{", "Project", ":", "project", "}", ")", "\n", "}" ]

[ "LookupByProject", "returns", "the", "project", "identity", "stored", "for", "a", "given", "project", "." ]

[ "func", "(", "s", "*", "persistentStorage", ")", "Delete", "(", "c", "context", ".", "Context", ",", "identity", "*", "ProjectIdentity", ")", "error", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "identity", ")", "\n", "return", "ds", ".", "Delete", "(", "c", ",", "identity", ")", "\n", "}" ]

[ "Delete", "removes", "an", "identity", "from", "the", "storage", "." ]

[ "func", "(", "s", "*", "persistentStorage", ")", "Create", "(", "c", "context", ".", "Context", ",", "identity", "*", "ProjectIdentity", ")", "(", "*", "ProjectIdentity", ",", "error", ")", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "identity", ")", "\n", "return", "s", ".", "Update", "(", "c", ",", "identity", ")", "\n", "}" ]

[ "Create", "stores", "a", "new", "entry", "for", "a", "project", "identity", "." ]

[ "func", "(", "s", "*", "StatsBase", ")", "Merge", "(", "o", "Stats", ")", "{", "s", ".", "F", ".", "SentBytes", "+=", "o", ".", "SentBytes", "(", ")", "\n", "s", ".", "F", ".", "SentMessages", "+=", "o", ".", "SentMessages", "(", ")", "\n", "s", ".", "F", ".", "DiscardedMessages", "+=", "o", ".", "DiscardedMessages", "(", ")", "\n", "s", ".", "F", ".", "Errors", "+=", "o", ".", "Errors", "(", ")", "\n", "}" ]

[ "Merge", "merges", "the", "values", "from", "one", "Stats", "block", "into", "another", "." ]

[ "func", "(", "t", "token", ")", "split", "(", ")", "(", "name", ",", "value", "string", ")", "{", "split", ":=", "strings", ".", "SplitN", "(", "string", "(", "t", ")", ",", "\"", "\"", ",", "2", ")", "\n", "name", "=", "split", "[", "0", "]", "\n", "if", "len", "(", "split", ")", "==", "2", "{", "value", "=", "split", "[", "1", "]", "\n", "}", "\n", "return", "\n", "}" ]

[ "split", "breaks", "a", "token", "into", "its", "name", "and", "value", "components", "." ]

[ "func", "(", "m", "*", "AuthMethod", ")", "InstallHandlers", "(", "r", "*", "router", ".", "Router", ",", "base", "router", ".", "MiddlewareChain", ")", "{", "r", ".", "GET", "(", "loginURL", ",", "base", ",", "m", ".", "loginHandler", ")", "\n", "r", ".", "GET", "(", "logoutURL", ",", "base", ",", "m", ".", "logoutHandler", ")", "\n", "r", ".", "GET", "(", "callbackURL", ",", "base", ",", "m", ".", "callbackHandler", ")", "\n", "}" ]

[ "InstallHandlers", "installs", "HTTP", "handlers", "used", "in", "OpenID", "protocol", ".", "Must", "be", "installed", "in", "server", "HTTP", "router", "for", "OpenID", "authentication", "flow", "to", "work", "." ]

[ "func", "(", "m", "*", "AuthMethod", ")", "Warmup", "(", "c", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "cfg", ",", "err", ":=", "fetchCachedSettings", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "cfg", ".", "DiscoveryURL", "!=", "\"", "\"", "{", "_", ",", "err", "=", "fetchDiscoveryDoc", "(", "c", ",", "cfg", ".", "DiscoveryURL", ")", "\n", "}", "else", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Warmup", "prepares", "local", "caches", ".", "It", "s", "optional", "." ]

[ "func", "(", "m", "*", "AuthMethod", ")", "Authenticate", "(", "c", "context", ".", "Context", ",", "r", "*", "http", ".", "Request", ")", "(", "*", "auth", ".", "User", ",", "error", ")", "{", "if", "m", ".", "SessionStore", "==", "nil", "{", "return", "nil", ",", "ErrNotConfigured", "\n", "}", "\n\n", "// Grab session ID from the cookie.", "sid", ",", "err", ":=", "decodeSessionCookie", "(", "c", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "sid", "==", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Grab session (with user information) from the store.", "session", ",", "err", ":=", "m", ".", "SessionStore", ".", "GetSession", "(", "c", ",", "sid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "session", "==", "nil", "{", "(", "logging", ".", "Fields", "{", "\"", "\"", ":", "sid", "}", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "(", "logging", ".", "Fields", "{", "\"", "\"", ":", "sid", ",", "\"", "\"", ":", "session", ".", "User", ".", "Email", ",", "}", ")", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "&", "session", ".", "User", ",", "nil", "\n", "}" ]

[ "Authenticate", "extracts", "peer", "s", "identity", "from", "the", "incoming", "request", ".", "It", "is", "part", "of", "auth", ".", "Method", "interface", "." ]

[ "func", "(", "m", "*", "AuthMethod", ")", "LoginURL", "(", "c", "context", ".", "Context", ",", "dest", "string", ")", "(", "string", ",", "error", ")", "{", "if", "m", ".", "SessionStore", "==", "nil", "{", "return", "\"", "\"", ",", "ErrNotConfigured", "\n", "}", "\n", "return", "makeRedirectURL", "(", "loginURL", ",", "dest", ")", "\n", "}" ]

[ "LoginURL", "returns", "a", "URL", "that", "when", "visited", "prompts", "the", "user", "to", "sign", "in", "then", "redirects", "the", "user", "to", "the", "URL", "specified", "by", "dest", ".", "It", "is", "part", "of", "auth", ".", "UsersAPI", "interface", "." ]

[ "func", "(", "m", "*", "AuthMethod", ")", "LogoutURL", "(", "c", "context", ".", "Context", ",", "dest", "string", ")", "(", "string", ",", "error", ")", "{", "if", "m", ".", "SessionStore", "==", "nil", "{", "return", "\"", "\"", ",", "ErrNotConfigured", "\n", "}", "\n", "return", "makeRedirectURL", "(", "logoutURL", ",", "dest", ")", "\n", "}" ]

[ "LogoutURL", "returns", "a", "URL", "that", "when", "visited", "signs", "the", "user", "out", "then", "redirects", "the", "user", "to", "the", "URL", "specified", "by", "dest", ".", "It", "is", "part", "of", "auth", ".", "UsersAPI", "interface", "." ]

[ "func", "(", "m", "*", "AuthMethod", ")", "logoutHandler", "(", "ctx", "*", "router", ".", "Context", ")", "{", "c", ",", "rw", ",", "r", ":=", "ctx", ".", "Context", ",", "ctx", ".", "Writer", ",", "ctx", ".", "Request", "\n\n", "dest", ",", "err", ":=", "normalizeURL", "(", "r", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "replyError", "(", "c", ",", "rw", ",", "err", ",", "\"", "\"", ",", "dest", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// Close a session if there's one.", "sid", ",", "err", ":=", "decodeSessionCookie", "(", "c", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "replyError", "(", "c", ",", "rw", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "sid", "!=", "\"", "\"", "{", "(", "logging", ".", "Fields", "{", "\"", "\"", ":", "sid", "}", ")", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "if", "err", "=", "m", ".", "SessionStore", ".", "CloseSession", "(", "c", ",", "sid", ")", ";", "err", "!=", "nil", "{", "replyError", "(", "c", ",", "rw", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "}", "\n\n", "// Nuke all session cookies to get to a completely clean state.", "removeCookie", "(", "rw", ",", "r", ",", "sessionCookieName", ")", "\n", "m", ".", "removeIncompatibleCookies", "(", "rw", ",", "r", ")", "\n\n", "// Redirect to the final destination.", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "dest", ")", "\n", "http", ".", "Redirect", "(", "rw", ",", "r", ",", "dest", ",", "http", ".", "StatusFound", ")", "\n", "}" ]

[ "logoutHandler", "nukes", "active", "session", "and", "redirect", "back", "to", "destination", "URL", "." ]

[ "func", "(", "m", "*", "AuthMethod", ")", "removeIncompatibleCookies", "(", "rw", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "for", "_", ",", "cookie", ":=", "range", "m", ".", "IncompatibleCookies", "{", "removeCookie", "(", "rw", ",", "r", ",", "cookie", ")", "\n", "}", "\n", "}" ]

[ "removeIncompatibleCookies", "removes", "cookies", "specified", "by", "m", ".", "IncompatibleCookies", "." ]

[ "func", "makeRedirectURL", "(", "base", ",", "dest", "string", ")", "(", "string", ",", "error", ")", "{", "dest", ",", "err", ":=", "normalizeURL", "(", "dest", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "v", ":=", "url", ".", "Values", "{", "}", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "dest", ")", "\n", "return", "base", "+", "\"", "\"", "+", "v", ".", "Encode", "(", ")", ",", "nil", "\n", "}" ]

[ "makeRedirectURL", "is", "used", "to", "generate", "login", "and", "logout", "URLs", "." ]

[ "func", "removeCookie", "(", "rw", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ",", "cookie", "string", ")", "{", "if", "prev", ",", "err", ":=", "r", ".", "Cookie", "(", "cookie", ")", ";", "err", "==", "nil", "{", "cpy", ":=", "*", "prev", "\n", "cpy", ".", "Value", "=", "\"", "\"", "\n", "cpy", ".", "Path", "=", "\"", "\"", "\n", "cpy", ".", "MaxAge", "=", "-", "1", "\n", "cpy", ".", "Expires", "=", "time", ".", "Unix", "(", "1", ",", "0", ")", "\n", "http", ".", "SetCookie", "(", "rw", ",", "&", "cpy", ")", "\n", "}", "\n", "}" ]

[ "removeCookie", "sets", "a", "cookie", "to", "past", "expiration", "date", "so", "that", "browser", "can", "remove", "it", ".", "Also", "replaced", "value", "with", "junk", "in", "case", "browser", "decides", "to", "ignore", "expiration", "time", "." ]

[ "func", "(", "a", "*", "Authenticator", ")", "GetMiddleware", "(", ")", "router", ".", "Middleware", "{", "return", "func", "(", "c", "*", "router", ".", "Context", ",", "next", "router", ".", "Handler", ")", "{", "ctx", ",", "err", ":=", "a", ".", "Authenticate", "(", "c", ".", "Context", ",", "c", ".", "Request", ")", "\n", "switch", "{", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "replyError", "(", "c", ".", "Context", ",", "c", ".", "Writer", ",", "500", ",", "\"", "\"", ",", "err", ")", "\n", "case", "err", "!=", "nil", ":", "replyError", "(", "c", ".", "Context", ",", "c", ".", "Writer", ",", "401", ",", "\"", "\"", ",", "err", ")", "\n", "default", ":", "c", ".", "Context", "=", "ctx", "\n", "next", "(", "c", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "GetMiddleware", "returns", "a", "middleware", "that", "uses", "this", "Authenticator", "for", "authentication", ".", "It", "uses", "a", ".", "Authenticate", "internally", "and", "handles", "errors", "appropriately", "." ]

[ "func", "(", "a", "*", "Authenticator", ")", "usersAPI", "(", ")", "UsersAPI", "{", "for", "_", ",", "m", ":=", "range", "a", ".", "Methods", "{", "if", "api", ",", "ok", ":=", "m", ".", "(", "UsersAPI", ")", ";", "ok", "{", "return", "api", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "usersAPI", "returns", "implementation", "of", "UsersAPI", "by", "examining", "Methods", ".", "Returns", "nil", "if", "none", "of", "Methods", "implement", "UsersAPI", "." ]

[ "func", "(", "a", "*", "Authenticator", ")", "LoginURL", "(", "c", "context", ".", "Context", ",", "dest", "string", ")", "(", "string", ",", "error", ")", "{", "if", "api", ":=", "a", ".", "usersAPI", "(", ")", ";", "api", "!=", "nil", "{", "return", "api", ".", "LoginURL", "(", "c", ",", "dest", ")", "\n", "}", "\n", "return", "\"", "\"", ",", "ErrNoUsersAPI", "\n", "}" ]

[ "LoginURL", "returns", "a", "URL", "that", "when", "visited", "prompts", "the", "user", "to", "sign", "in", "then", "redirects", "the", "user", "to", "the", "URL", "specified", "by", "dest", ".", "Returns", "ErrNoUsersAPI", "if", "none", "of", "the", "authentication", "methods", "support", "login", "URLs", "." ]

[ "func", "(", "a", "*", "Attempt_ID", ")", "DMEncoded", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "a", ".", "Quest", ",", "flipMask", "^", "a", ".", "Id", ")", "\n", "}" ]

[ "DMEncoded", "returns", "the", "encoded", "string", "id", "for", "this", "Attempt", ".", "Numeric", "values", "are", "inverted", "if", "flip", "is", "true", "." ]

[ "func", "(", "a", "*", "Attempt_ID", ")", "SetDMEncoded", "(", "val", "string", ")", "error", "{", "toks", ":=", "strings", ".", "SplitN", "(", "val", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "toks", ")", "!=", "2", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n", "an", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "toks", "[", "1", "]", ",", "16", ",", "32", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "a", ".", "Quest", "=", "toks", "[", "0", "]", "\n", "a", ".", "Id", "=", "flipMask", "^", "uint32", "(", "an", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetDMEncoded", "decodes", "val", "into", "this", "Attempt_ID", "returning", "an", "error", "if", "there", "s", "a", "problem", ".", "Numeric", "values", "are", "inverted", "if", "flip", "is", "true", "." ]

[ "func", "(", "g", "*", "GraphData", ")", "GetQuest", "(", "qid", "string", ")", "(", "*", "Quest", ",", "bool", ")", "{", "cur", ",", "ok", ":=", "g", ".", "Quests", "[", "qid", "]", "\n", "if", "!", "ok", "{", "cur", "=", "&", "Quest", "{", "Id", ":", "NewQuestID", "(", "qid", ")", ",", "Attempts", ":", "map", "[", "uint32", "]", "*", "Attempt", "{", "}", ",", "}", "\n", "if", "g", ".", "Quests", "==", "nil", "{", "g", ".", "Quests", "=", "map", "[", "string", "]", "*", "Quest", "{", "}", "\n", "}", "\n", "g", ".", "Quests", "[", "qid", "]", "=", "cur", "\n", "}", "\n", "return", "cur", ",", "ok", "\n", "}" ]

[ "GetQuest", "gets", "the", "specified", "quest", "from", "GraphData", "if", "it", "s", "already", "there", ".", "If", "it", "s", "not", "then", "a", "new", "Quest", "will", "be", "created", "added", "and", "returned", ".", "If", "the", "Quests", "map", "is", "uninitialized", "this", "will", "initialize", "it", "." ]

[ "func", "(", "t", "*", "Quest_TemplateSpec", ")", "Equals", "(", "o", "*", "Quest_TemplateSpec", ")", "bool", "{", "return", "proto", ".", "Equal", "(", "t", ",", "o", ")", "\n", "}" ]

[ "Equals", "returns", "true", "iff", "this", "Quest_TemplateSpec", "matches", "all", "of", "the", "fields", "of", "the", "o", "Quest_TemplateSpec", "." ]

[ "func", "MakeExecution", "(", "c", "context", ".", "Context", ",", "e", "*", "dm", ".", "Execution_ID", ",", "cfgName", ",", "cfgVers", "string", ")", "*", "Execution", "{", "now", ":=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "\n", "ret", ":=", "&", "Execution", "{", "ID", ":", "invertedHexUint32", "(", "e", ".", "Id", ")", ",", "Attempt", ":", "AttemptKeyFromID", "(", "c", ",", "e", ".", "AttemptID", "(", ")", ")", ",", "Created", ":", "now", ",", "Modified", ":", "now", ",", "DistributorConfigName", ":", "cfgName", ",", "DistributorConfigVersion", ":", "cfgVers", ",", "Token", ":", "MakeRandomToken", "(", "c", ",", "dm", ".", "MinimumActivationTokenLength", ")", ",", "}", "\n", "return", "ret", "\n", "}" ]

[ "MakeExecution", "makes", "a", "new", "Execution", "in", "the", "SCHEDULING", "state", "with", "a", "new", "random", "Token", "." ]

[ "func", "(", "e", "*", "Execution", ")", "ModifyState", "(", "c", "context", ".", "Context", ",", "newState", "dm", ".", "Execution_State", ")", "error", "{", "if", "e", ".", "State", "==", "newState", "{", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "e", ".", "State", ".", "Evolve", "(", "newState", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "now", ":=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "\n", "if", "now", ".", "After", "(", "e", ".", "Modified", ")", "{", "e", ".", "Modified", "=", "now", "\n", "}", "else", "{", "// Microsecond is the smallest granularity that datastore can store", "// timestamps, so use that to disambiguate: the goal here is that any", "// modification always increments the modified time, and never decrements", "// it.", "e", ".", "Modified", "=", "e", ".", "Modified", ".", "Add", "(", "time", ".", "Microsecond", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ModifyState", "changes", "the", "current", "state", "of", "this", "Execution", "and", "updates", "its", "Modified", "timestamp", "." ]

[ "func", "MakeRandomToken", "(", "c", "context", ".", "Context", ",", "l", "uint32", ")", "[", "]", "byte", "{", "rtok", ":=", "make", "(", "[", "]", "byte", ",", "l", ")", "\n", "if", "_", ",", "err", ":=", "cryptorand", ".", "Read", "(", "c", ",", "rtok", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "rtok", "\n", "}" ]

[ "MakeRandomToken", "creates", "a", "cryptographically", "random", "byte", "slice", "of", "the", "specified", "length", ".", "It", "panics", "if", "the", "specified", "length", "cannot", "be", "read", "in", "full", "." ]

[ "func", "(", "e", "*", "Execution", ")", "Revoke", "(", "c", "context", ".", "Context", ")", "error", "{", "e", ".", "Token", "=", "nil", "\n", "if", "err", ":=", "e", ".", "ModifyState", "(", "c", ",", "dm", ".", "Execution_STOPPING", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "ds", ".", "Put", "(", "c", ",", "e", ")", "\n", "}" ]

[ "Revoke", "will", "clear", "the", "Token", "and", "Put", "this", "Execution", "to", "the", "datastore", ".", "This", "action", "requires", "the", "Execution", "to", "be", "in", "the", "RUNNING", "state", "and", "causes", "it", "to", "enter", "the", "STOPPING", "state", "." ]

[ "func", "AuthenticateExecution", "(", "c", "context", ".", "Context", ",", "auth", "*", "dm", ".", "Execution_Auth", ")", "(", "a", "*", "Attempt", ",", "e", "*", "Execution", ",", "err", "error", ")", "{", "a", ",", "e", ",", "err", "=", "verifyExecutionAndCheckExTok", "(", "c", ",", "auth", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Fields", "{", "ek", ":", "err", ",", "\"", "\"", ":", "auth", ".", "Id", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "err", "=", "makeError", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "a", ",", "e", ",", "err", "\n", "}" ]

[ "AuthenticateExecution", "verifies", "that", "the", "Attempt", "is", "executing", "and", "that", "evkey", "matches", "the", "execution", "key", "of", "the", "current", "Execution", "for", "this", "Attempt", ".", "As", "a", "bonus", "it", "will", "return", "the", "loaded", "Attempt", "and", "Execution", "." ]

[ "func", "InvalidateExecution", "(", "c", "context", ".", "Context", ",", "auth", "*", "dm", ".", "Execution_Auth", ")", "(", "a", "*", "Attempt", ",", "e", "*", "Execution", ",", "err", "error", ")", "{", "if", "a", ",", "e", ",", "err", "=", "verifyExecutionAndCheckExTok", "(", "c", ",", "auth", ")", ";", "err", "!=", "nil", "{", "logging", ".", "Fields", "{", "ek", ":", "err", ",", "\"", "\"", ":", "auth", ".", "Id", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "err", "=", "makeError", "(", "err", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "err", "=", "e", ".", "Revoke", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Fields", "{", "ek", ":", "err", ",", "\"", "\"", ":", "auth", ".", "Id", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "err", "=", "makeError", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "InvalidateExecution", "verifies", "that", "the", "execution", "key", "is", "valid", "and", "then", "revokes", "the", "execution", "key", ".", "As", "a", "bonus", "it", "will", "return", "the", "loaded", "Attempt", "and", "Execution", "." ]

[ "func", "ActivateExecution", "(", "c", "context", ".", "Context", ",", "auth", "*", "dm", ".", "Execution_Auth", ",", "actToken", "[", "]", "byte", ")", "(", "a", "*", "Attempt", ",", "e", "*", "Execution", ",", "err", "error", ")", "{", "a", ",", "e", ",", "err", "=", "verifyExecutionAndActivate", "(", "c", ",", "auth", ",", "actToken", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Fields", "{", "ek", ":", "err", ",", "\"", "\"", ":", "auth", ".", "Id", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "err", "=", "makeError", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "a", ",", "e", ",", "err", "\n", "}" ]

[ "ActivateExecution", "validates", "that", "the", "execution", "is", "unactivated", "and", "that", "the", "activation", "token", "matches", "and", "then", "sets", "the", "token", "to", "the", "new", "value", ".", "It", "s", "OK", "to", "retry", "this", ".", "Subsequent", "invocations", "with", "the", "same", "Token", "will", "recognize", "this", "case", "and", "not", "return", "an", "error", "." ]

[ "func", "(", "e", "*", "Execution", ")", "GetEID", "(", ")", "*", "dm", ".", "Execution_ID", "{", "aid", ":=", "&", "dm", ".", "Attempt_ID", "{", "}", "\n", "if", "e", ".", "ID", "==", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "aid", ".", "SetDMEncoded", "(", "e", ".", "Attempt", ".", "StringID", "(", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "dm", ".", "NewExecutionID", "(", "aid", ".", "Quest", ",", "aid", ".", "Id", ",", "uint32", "(", "e", ".", "ID", ")", ")", "\n", "}" ]

[ "GetEID", "gets", "an", "Execution_ID", "for", "this", "Execution", ".", "It", "panics", "if", "the", "Execution", "is", "in", "an", "invalid", "state", "." ]

[ "func", "(", "e", "*", "Execution", ")", "ToProto", "(", "includeID", "bool", ")", "*", "dm", ".", "Execution", "{", "ret", ":=", "&", "dm", ".", "Execution", "{", "Data", ":", "e", ".", "DataProto", "(", ")", "}", "\n", "if", "includeID", "{", "ret", ".", "Id", "=", "e", ".", "GetEID", "(", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "ToProto", "returns", "a", "dm", "proto", "version", "of", "this", "Execution", "." ]

[ "func", "(", "e", "*", "Execution", ")", "DataProto", "(", ")", "(", "ret", "*", "dm", ".", "Execution_Data", ")", "{", "switch", "e", ".", "State", "{", "case", "dm", ".", "Execution_SCHEDULING", ":", "ret", "=", "dm", ".", "NewExecutionScheduling", "(", ")", ".", "Data", "\n", "case", "dm", ".", "Execution_RUNNING", ":", "ret", "=", "dm", ".", "NewExecutionRunning", "(", ")", ".", "Data", "\n", "case", "dm", ".", "Execution_STOPPING", ":", "ret", "=", "dm", ".", "NewExecutionStopping", "(", ")", ".", "Data", "\n", "case", "dm", ".", "Execution_FINISHED", ":", "ret", "=", "dm", ".", "NewExecutionFinished", "(", "e", ".", "Result", ".", "Data", ")", ".", "Data", "\n", "case", "dm", ".", "Execution_ABNORMAL_FINISHED", ":", "ret", "=", "dm", ".", "NewExecutionAbnormalFinish", "(", "e", ".", "Result", ".", "AbnormalFinish", ")", ".", "Data", "\n", "default", ":", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "State", ")", ")", "\n", "}", "\n", "ret", ".", "Created", "=", "google_pb", ".", "NewTimestamp", "(", "e", ".", "Created", ")", "\n", "ret", ".", "Modified", "=", "google_pb", ".", "NewTimestamp", "(", "e", ".", "Modified", ")", "\n", "ret", ".", "DistributorInfo", "=", "&", "dm", ".", "Execution_Data_DistributorInfo", "{", "ConfigName", ":", "e", ".", "DistributorConfigName", ",", "ConfigVersion", ":", "e", ".", "DistributorConfigVersion", ",", "Token", ":", "e", ".", "DistributorToken", ",", "}", "\n", "return", "ret", "\n", "}" ]

[ "DataProto", "returns", "an", "Execution", ".", "Data", "message", "for", "this", "Execution", ".", "This", "omits", "the", "DistributorInfo", ".", "Url", "portion", "which", "must", "be", "filled", "in", "elsewhere", "for", "package", "cyclical", "import", "reasons", "." ]

[ "func", "(", "x", "duration", ")", "String", "(", ")", "string", "{", "ms", ",", "ok", ":=", "x", ".", "Int64", "(", ")", "\n", "if", "!", "ok", "{", "return", "\"", "\"", "// probably very-very large", "\n", "}", "\n", "return", "(", "time", ".", "Duration", "(", "ms", ")", "*", "time", ".", "Millisecond", ")", ".", "String", "(", ")", "\n", "}" ]

[ "String", "formats", "the", "duration", "using", "Go", "s", "time", ".", "Duration", "rules", "." ]

[ "func", "(", "x", "duration", ")", "CompareSameType", "(", "op", "syntax", ".", "Token", ",", "y", "starlark", ".", "Value", ",", "depth", "int", ")", "(", "bool", ",", "error", ")", "{", "return", "x", ".", "Int", ".", "CompareSameType", "(", "op", ",", "y", ".", "(", "duration", ")", ".", "Int", ",", "depth", ")", "\n", "}" ]

[ "CompareSameType", "makes", "durations", "comparable", "by", "comparing", "them", "as", "integers", "." ]

[ "func", "(", "x", "duration", ")", "Binary", "(", "op", "syntax", ".", "Token", ",", "y", "starlark", ".", "Value", ",", "side", "starlark", ".", "Side", ")", "(", "starlark", ".", "Value", ",", "error", ")", "{", "switch", "y", ":=", "y", ".", "(", "type", ")", "{", "case", "starlark", ".", "Int", ":", "switch", "{", "case", "op", "==", "syntax", ".", "STAR", ":", "return", "duration", "{", "x", ".", "Int", ".", "Mul", "(", "y", ")", "}", ",", "nil", "\n", "case", "op", "==", "syntax", ".", "SLASH", "&&", "side", "==", "starlark", ".", "Left", ":", "return", "duration", "{", "x", ".", "Int", ".", "Div", "(", "y", ")", "}", ",", "nil", "\n", "}", "\n\n", "case", "duration", ":", "switch", "{", "case", "op", "==", "syntax", ".", "PLUS", ":", "return", "duration", "{", "x", ".", "Int", ".", "Add", "(", "y", ".", "Int", ")", "}", ",", "nil", "\n", "case", "op", "==", "syntax", ".", "MINUS", "&&", "side", "==", "starlark", ".", "Left", ":", "return", "duration", "{", "x", ".", "Int", ".", "Sub", "(", "y", ".", "Int", ")", "}", ",", "nil", "\n", "case", "op", "==", "syntax", ".", "MINUS", "&&", "side", "==", "starlark", ".", "Right", ":", "return", "duration", "{", "y", ".", "Int", ".", "Sub", "(", "x", ".", "Int", ")", "}", ",", "nil", "\n", "case", "op", "==", "syntax", ".", "SLASH", "&&", "side", "==", "starlark", ".", "Left", ":", "return", "x", ".", "Int", ".", "Div", "(", "y", ".", "Int", ")", ",", "nil", "\n", "case", "op", "==", "syntax", ".", "SLASH", "&&", "side", "==", "starlark", ".", "Right", ":", "return", "y", ".", "Int", ".", "Div", "(", "x", ".", "Int", ")", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// All other combinations aren't supported.", "return", "nil", ",", "nil", "\n", "}" ]

[ "Binary", "implements", "binary", "operations", "between", "durations", "and", "ints", "." ]

[ "func", "(", "x", "duration", ")", "Unary", "(", "op", "syntax", ".", "Token", ")", "(", "starlark", ".", "Value", ",", "error", ")", "{", "switch", "op", "{", "case", "syntax", ".", "PLUS", ":", "return", "x", ",", "nil", "\n", "case", "syntax", ".", "MINUS", ":", "return", "duration", "{", "zero", ".", "Sub", "(", "x", ".", "Int", ")", "}", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Unary", "implements", "+", "-", "." ]

[ "func", "(", "p", "*", "Parsed", ")", "FieldsBlock", "(", "title", "string", ")", "FieldsBlock", "{", "for", "_", ",", "b", ":=", "range", "p", ".", "Fields", "{", "if", "b", ".", "Title", "==", "title", "{", "return", "b", "\n", "}", "\n", "}", "\n", "return", "FieldsBlock", "{", "}", "\n", "}" ]

[ "FieldsBlock", "returns", "a", "fields", "block", "with", "the", "given", "title", "or", "an", "empty", "block", "if", "not", "found", "." ]

[ "func", "(", "p", "*", "Parsed", ")", "RemarkBlock", "(", "title", "string", ")", "RemarkBlock", "{", "for", "_", ",", "b", ":=", "range", "p", ".", "Remarks", "{", "if", "b", ".", "Title", "==", "title", "{", "return", "b", "\n", "}", "\n", "}", "\n", "return", "RemarkBlock", "{", "}", "\n", "}" ]

[ "RemarkBlock", "returns", "a", "remark", "block", "with", "the", "given", "title", "or", "an", "empty", "block", "if", "not", "found", "." ]

[ "func", "trimEmptyLines", "(", "lines", "[", "]", "string", ")", "[", "]", "string", "{", "for", "len", "(", "lines", ")", ">", "0", "&&", "lines", "[", "0", "]", "==", "\"", "\"", "{", "lines", "=", "lines", "[", "1", ":", "]", "\n", "}", "\n", "for", "len", "(", "lines", ")", ">", "0", "&&", "lines", "[", "len", "(", "lines", ")", "-", "1", "]", "==", "\"", "\"", "{", "lines", "=", "lines", "[", ":", "len", "(", "lines", ")", "-", "1", "]", "\n", "}", "\n", "return", "lines", "\n", "}" ]

[ "trimEmptyLines", "removes", "leading", "and", "trailing", "empty", "lines", "from", "the", "slice", "." ]

[ "func", "countLeadingSpace", "(", "s", "string", ")", "(", "runes", "int", ")", "{", "for", "_", ",", "r", ":=", "range", "s", "{", "if", "!", "unicode", ".", "IsSpace", "(", "r", ")", "{", "break", "\n", "}", "\n", "runes", "++", "\n", "}", "\n", "return", "\n", "}" ]

[ "countLeadingSpace", "returns", "number", "of", "space", "runes", "at", "the", "prefix", "of", "a", "string", "." ]

[ "func", "hasLeadingSpace", "(", "s", "string", ")", "bool", "{", "for", "_", ",", "r", ":=", "range", "s", "{", "return", "unicode", ".", "IsSpace", "(", "r", ")", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "hasLeadingSpace", "returns", "true", "if", "s", "starts", "with", "a", "space", "." ]

[ "func", "(", "k", "*", "Key", ")", "ParamHash", "(", ")", "[", "]", "byte", "{", "cstr", ":=", "\"", "\"", "\n", "if", "k", ".", "Content", "{", "cstr", "=", "\"", "\"", "\n", "}", "\n", "return", "HashParams", "(", "k", ".", "Schema", ",", "k", ".", "ServiceURL", ",", "string", "(", "k", ".", "Authority", ")", ",", "string", "(", "k", ".", "Op", ")", ",", "cstr", ",", "k", ".", "Formatter", ",", "k", ".", "FormatData", ",", "string", "(", "k", ".", "ConfigSet", ")", ",", "k", ".", "Path", ",", "string", "(", "k", ".", "GetAllTarget", ")", ")", "\n", "}" ]

[ "ParamHash", "returns", "a", "deterministic", "hash", "of", "all", "of", "the", "key", "parameters", "." ]