Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "e", "*", "engineImpl", ")", "PullPubSubOnDevServer", "(", "c", "context", ".", "Context", ",", "taskManagerName", ",", "publisher", "string", ")", "error", "{", "_", ",", "sub", ":=", "e", ".", "genTopicAndSubNames", "(", "c", ",", "taskManagerName", ",", "publisher", ")", "\n", "msg", ",", "ack", ",", "err", ":=", "pullSubcription", "(", "c", ",", "sub", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "msg", "==", "nil", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "switch", "err", "=", "e", ".", "handlePubSubMessage", "(", "c", ",", "msg", ")", ";", "{", "case", "err", "==", "nil", ":", "ack", "(", ")", "// success", "\n", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", "||", "tq", ".", "Retry", ".", "In", "(", "err", ")", ":", "// don't ack, ask for redelivery", "default", ":", "ack", "(", ")", "// fatal error", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "PullPubSubOnDevServer", "is", "called", "on", "dev", "server", "to", "pull", "messages", "from", "PubSub", "subscription", "associated", "with", "given", "publisher", ".", "Part", "of", "the", "internal", "interface", "doesn", "t", "check", "ACLs", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "GetDebugJobState", "(", "c", "context", ".", "Context", ",", "jobID", "string", ")", "(", "*", "DebugJobState", ",", "error", ")", "{", "job", ",", "err", ":=", "e", ".", "getJob", "(", "c", ",", "jobID", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "job", "==", "nil", ":", "return", "nil", ",", "ErrNoSuchJob", "\n", "}", "\n\n", "state", ":=", "&", "DebugJobState", "{", "Job", ":", "job", "}", "\n\n", "// Fill in FinishedInvocations.", "state", ".", "FinishedInvocations", ",", "err", "=", "unmarshalFinishedInvs", "(", "job", ".", "FinishedInvocationsRaw", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Fill in RecentlyFinishedSet.", "finishedSet", ":=", "recentlyFinishedSet", "(", "c", ",", "jobID", ")", "\n", "listing", ",", "err", ":=", "finishedSet", ".", "List", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "state", ".", "RecentlyFinishedSet", "=", "make", "(", "[", "]", "int64", ",", "len", "(", "listing", ".", "Items", ")", ")", "\n", "for", "i", ",", "itm", ":=", "range", "listing", ".", "Items", "{", "state", ".", "RecentlyFinishedSet", "[", "i", "]", "=", "finishedSet", ".", "ItemToInvID", "(", "&", "itm", ")", "\n", "}", "\n\n", "// Fill in PendingTriggersSet.", "triggersSet", ":=", "pendingTriggersSet", "(", "c", ",", "jobID", ")", "\n", "_", ",", "state", ".", "PendingTriggersSet", ",", "err", "=", "triggersSet", ".", "Triggers", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Ask the corresponding task.Manager to fill in DebugManagerState. Pass it", "// a phony controller configured just enough to be useful for fetching the", "// state, but not anything else.", "ctl", ",", "err", ":=", "controllerForInvocation", "(", "c", ",", "e", ",", "&", "Invocation", "{", "ID", ":", "-", "1", ",", "JobID", ":", "jobID", ",", "Task", ":", "job", ".", "Task", ",", "}", ")", "\n", "if", "err", "==", "nil", "{", "state", ".", "ManagerState", ",", "err", "=", "ctl", ".", "manager", ".", "GetDebugState", "(", "c", ",", "ctl", ")", "\n", "}", "\n", "if", "state", ".", "ManagerState", "==", "nil", "{", "state", ".", "ManagerState", "=", "&", "internal", ".", "DebugManagerState", "{", "}", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "state", ".", "ManagerState", ".", "Error", "=", "err", ".", "Error", "(", ")", "\n", "}", "\n", "if", "ctl", "!=", "nil", "{", "state", ".", "ManagerState", ".", "DebugLog", "=", "ctl", ".", "debugLog", "\n", "}", "\n\n", "return", "state", ",", "nil", "\n", "}" ]

[ "GetDebugJobState", "is", "used", "by", "Admin", "RPC", "interface", "for", "debugging", "jobs", ".", "Part", "of", "the", "internal", "interface", "doesn", "t", "check", "ACLs", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "getJob", "(", "c", "context", ".", "Context", ",", "jobID", "string", ")", "(", "*", "Job", ",", "error", ")", "{", "job", ":=", "&", "Job", "{", "JobID", ":", "jobID", "}", "\n", "switch", "err", ":=", "ds", ".", "Get", "(", "c", ",", "job", ")", ";", "{", "case", "err", "==", "nil", ":", "return", "job", ",", "nil", "\n", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "return", "nil", ",", "nil", "\n", "default", ":", "return", "nil", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "getJob", "returns", "a", "job", "if", "it", "exists", "or", "nil", "if", "not", ".", "Doesn", "t", "check", "ACLs", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "getProjectJobs", "(", "c", "context", ".", "Context", ",", "projectID", "string", ")", "(", "map", "[", "string", "]", "*", "Job", ",", "error", ")", "{", "q", ":=", "ds", ".", "NewQuery", "(", "\"", "\"", ")", ".", "Eq", "(", "\"", "\"", ",", "true", ")", ".", "Eq", "(", "\"", "\"", ",", "projectID", ")", "\n", "entities", ":=", "[", "]", "*", "Job", "{", "}", "\n", "if", "err", ":=", "ds", ".", "GetAll", "(", "c", ",", "q", ",", "&", "entities", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n", "out", ":=", "make", "(", "map", "[", "string", "]", "*", "Job", ",", "len", "(", "entities", ")", ")", "\n", "for", "_", ",", "job", ":=", "range", "entities", "{", "if", "job", ".", "Enabled", "&&", "job", ".", "ProjectID", "==", "projectID", "{", "out", "[", "job", ".", "JobID", "]", "=", "job", "\n", "}", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "getProjectJobs", "fetches", "from", "ds", "all", "enabled", "jobs", "belonging", "to", "a", "given", "project", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "queryEnabledVisibleJobs", "(", "c", "context", ".", "Context", ",", "q", "*", "ds", ".", "Query", ")", "(", "[", "]", "*", "Job", ",", "error", ")", "{", "entities", ":=", "[", "]", "*", "Job", "{", "}", "\n", "if", "err", ":=", "ds", ".", "GetAll", "(", "c", ",", "q", ",", "&", "entities", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n", "// Non-ancestor query used, need to recheck filters.", "enabled", ":=", "make", "(", "[", "]", "*", "Job", ",", "0", ",", "len", "(", "entities", ")", ")", "\n", "for", "_", ",", "job", ":=", "range", "entities", "{", "if", "job", ".", "Enabled", "{", "enabled", "=", "append", "(", "enabled", ",", "job", ")", "\n", "}", "\n", "}", "\n", "// Keep only ones visible to the caller.", "return", "e", ".", "filterForRole", "(", "c", ",", "enabled", ",", "acl", ".", "Reader", ")", "\n", "}" ]

[ "queryEnabledVisibleJobs", "fetches", "all", "jobs", "from", "the", "query", "and", "keeps", "only", "ones", "that", "are", "enabled", "and", "visible", "by", "the", "current", "caller", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "filterForRole", "(", "c", "context", ".", "Context", ",", "jobs", "[", "]", "*", "Job", ",", "role", "acl", ".", "Role", ")", "(", "[", "]", "*", "Job", ",", "error", ")", "{", "// TODO(tandrii): improve batch ACLs check here to take advantage of likely", "// shared ACLs between most jobs of the same project.", "filtered", ":=", "make", "(", "[", "]", "*", "Job", ",", "0", ",", "len", "(", "jobs", ")", ")", "\n", "for", "_", ",", "job", ":=", "range", "jobs", "{", "switch", "err", ":=", "job", ".", "CheckRole", "(", "c", ",", "role", ")", ";", "{", "case", "err", "==", "nil", ":", "filtered", "=", "append", "(", "filtered", ",", "job", ")", "\n", "case", "err", "!=", "ErrNoPermission", ":", "return", "nil", ",", "err", "// a transient error when checking", "\n", "}", "\n", "}", "\n", "return", "filtered", ",", "nil", "\n", "}" ]

[ "filterForRole", "returns", "jobs", "for", "which", "caller", "has", "the", "given", "role", ".", "May", "return", "transient", "errors", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "updateJob", "(", "c", "context", ".", "Context", ",", "def", "catalog", ".", "Definition", ")", "error", "{", "return", "e", ".", "jobTxn", "(", "c", ",", "def", ".", "JobID", ",", "func", "(", "c", "context", ".", "Context", ",", "job", "*", "Job", ",", "isNew", "bool", ")", "error", "{", "if", "!", "isNew", "&&", "job", ".", "Enabled", "&&", "job", ".", "MatchesDefinition", "(", "def", ")", "{", "return", "errSkipPut", "\n", "}", "\n\n", "if", "isNew", "{", "// JobID is <projectID>/<name>, it's ensured by Catalog.", "chunks", ":=", "strings", ".", "Split", "(", "def", ".", "JobID", ",", "\"", "\"", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "def", ".", "JobID", ")", "\n", "}", "\n", "*", "job", "=", "Job", "{", "JobID", ":", "def", ".", "JobID", ",", "ProjectID", ":", "chunks", "[", "0", "]", ",", "Flavor", ":", "def", ".", "Flavor", ",", "Enabled", ":", "false", ",", "// to trigger 'if wasDisabled' below", "Schedule", ":", "def", ".", "Schedule", ",", "Task", ":", "def", ".", "Task", ",", "TriggeringPolicyRaw", ":", "def", ".", "TriggeringPolicy", ",", "TriggeredJobIDs", ":", "def", ".", "TriggeredJobIDs", ",", "}", "\n", "}", "\n", "wasDisabled", ":=", "!", "job", ".", "Enabled", "\n", "oldEffectiveSchedule", ":=", "job", ".", "EffectiveSchedule", "(", ")", "\n", "oldTriggeringPolicy", ":=", "job", ".", "TriggeringPolicyRaw", "\n\n", "// Update the job in full before running any state changes.", "job", ".", "Flavor", "=", "def", ".", "Flavor", "\n", "job", ".", "Revision", "=", "def", ".", "Revision", "\n", "job", ".", "RevisionURL", "=", "def", ".", "RevisionURL", "\n", "job", ".", "Acls", "=", "def", ".", "Acls", "\n", "job", ".", "Enabled", "=", "true", "\n", "job", ".", "Schedule", "=", "def", ".", "Schedule", "\n", "job", ".", "Task", "=", "def", ".", "Task", "\n", "job", ".", "TriggeringPolicyRaw", "=", "def", ".", "TriggeringPolicy", "\n", "job", ".", "TriggeredJobIDs", "=", "def", ".", "TriggeredJobIDs", "\n\n", "// If job triggering policy has changed, schedule a triage to potentially", "// act based on the new policy.", "if", "!", "bytes", ".", "Equal", "(", "oldTriggeringPolicy", ",", "job", ".", "TriggeringPolicyRaw", ")", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "e", ".", "kickTriageLater", "(", "c", ",", "job", ".", "JobID", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// If the job was just enabled or its schedule changed, poke the cron", "// machine to potentially schedule a new tick.", "return", "pokeCron", "(", "c", ",", "job", ",", "e", ".", "cfg", ".", "Dispatcher", ",", "func", "(", "m", "*", "cron", ".", "Machine", ")", "error", "{", "if", "wasDisabled", "{", "m", ".", "Enable", "(", ")", "\n", "}", "\n", "if", "job", ".", "EffectiveSchedule", "(", ")", "!=", "oldEffectiveSchedule", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "job", ".", "EffectiveSchedule", "(", ")", ",", "oldEffectiveSchedule", ")", "\n", "m", ".", "OnScheduleChange", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}", ")", "\n", "}" ]

[ "updateJob", "updates", "an", "existing", "job", "if", "its", "definition", "has", "changed", "adds", "a", "completely", "new", "job", "or", "enables", "a", "previously", "disabled", "job", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "disableJob", "(", "c", "context", ".", "Context", ",", "jobID", "string", ")", "error", "{", "return", "e", ".", "jobTxn", "(", "c", ",", "jobID", ",", "func", "(", "c", "context", ".", "Context", ",", "job", "*", "Job", ",", "isNew", "bool", ")", "error", "{", "if", "isNew", "||", "!", "job", ".", "Enabled", "{", "return", "errSkipPut", "\n", "}", "\n", "job", ".", "Enabled", "=", "false", "\n\n", "// Stop the cron machine ticks.", "err", ":=", "pokeCron", "(", "c", ",", "job", ",", "e", ".", "cfg", ".", "Dispatcher", ",", "func", "(", "m", "*", "cron", ".", "Machine", ")", "error", "{", "m", ".", "Disable", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Kick the triage to clear the pending triggers. We can pop them only", "// from within the triage procedure.", "return", "e", ".", "kickTriageLater", "(", "c", ",", "job", ".", "JobID", ",", "0", ")", "\n", "}", ")", "\n", "}" ]

[ "disableJob", "moves", "a", "job", "to", "the", "disabled", "state", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "allocateInvocation", "(", "c", "context", ".", "Context", ",", "job", "*", "Job", ",", "req", "task", ".", "Request", ")", "(", "*", "Invocation", ",", "error", ")", "{", "var", "inv", "*", "Invocation", "\n", "err", ":=", "runIsolatedTxn", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "inv", ",", "err", "=", "e", ".", "initInvocation", "(", "c", ",", "job", ".", "JobID", ",", "&", "Invocation", "{", "Started", ":", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", ",", "Revision", ":", "job", ".", "Revision", ",", "RevisionURL", ":", "job", ".", "RevisionURL", ",", "Task", ":", "job", ".", "Task", ",", "TriggeredJobIDs", ":", "job", ".", "TriggeredJobIDs", ",", "Status", ":", "task", ".", "StatusStarting", ",", "}", ",", "&", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "inv", ".", "debugLog", "(", "c", ",", "\"", "\"", ")", "\n", "if", "req", ".", "TriggeredBy", "!=", "\"", "\"", "{", "inv", ".", "debugLog", "(", "c", ",", "\"", "\"", ",", "req", ".", "TriggeredBy", ")", "\n", "}", "\n", "return", "transient", ".", "Tag", ".", "Apply", "(", "ds", ".", "Put", "(", "c", ",", "inv", ")", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "inv", ",", "nil", "\n", "}" ]

[ "allocateInvocation", "creates", "new", "Invocation", "entity", "in", "a", "separate", "transaction", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "allocateInvocations", "(", "c", "context", ".", "Context", ",", "job", "*", "Job", ",", "req", "[", "]", "task", ".", "Request", ")", "(", "[", "]", "*", "Invocation", ",", "error", ")", "{", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "wg", ".", "Add", "(", "len", "(", "req", ")", ")", "\n\n", "invs", ":=", "make", "(", "[", "]", "*", "Invocation", ",", "len", "(", "req", ")", ")", "\n", "merr", ":=", "errors", ".", "NewLazyMultiError", "(", "len", "(", "req", ")", ")", "\n", "for", "i", ":=", "range", "req", "{", "go", "func", "(", "i", "int", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "inv", ",", "err", ":=", "e", ".", "allocateInvocation", "(", "c", ",", "job", ",", "req", "[", "i", "]", ")", "\n", "invs", "[", "i", "]", "=", "inv", "\n", "merr", ".", "Assign", "(", "i", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "len", "(", "req", "[", "i", "]", ".", "IncomingTriggers", ")", ")", "\n", "}", "\n", "}", "(", "i", ")", "\n", "}", "\n\n", "wg", ".", "Wait", "(", ")", "\n\n", "// Bail if any of them failed. Try best effort cleanup.", "if", "err", ":=", "merr", ".", "Get", "(", ")", ";", "err", "!=", "nil", "{", "cleanupUnreferencedInvocations", "(", "c", ",", "invs", ")", "\n", "return", "nil", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n\n", "return", "invs", ",", "nil", "\n", "}" ]

[ "allocateInvocations", "is", "a", "batch", "version", "of", "allocateInvocation", ".", "It", "launches", "N", "independent", "transactions", "in", "parallel", "to", "create", "N", "invocations", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "abortInvocation", "(", "c", "context", ".", "Context", ",", "jobID", "string", ",", "invID", "int64", ")", "error", "{", "return", "e", ".", "withController", "(", "c", ",", "jobID", ",", "invID", ",", "\"", "\"", ",", "func", "(", "c", "context", ".", "Context", ",", "ctl", "*", "taskController", ")", "error", "{", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "auth", ".", "CurrentIdentity", "(", "c", ")", ")", "\n\n", "switch", "err", ":=", "ctl", ".", "manager", ".", "AbortTask", "(", "c", ",", "ctl", ")", ";", "{", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "return", "err", "// ask for retry on transient errors, don't touch Invocation", "\n", "case", "err", "!=", "nil", ":", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// On success or on a fatal error mark the task as aborted (unless the", "// manager already switched the state). We can't do anything about the", "// failed abort attempt anyway.", "if", "!", "ctl", ".", "State", "(", ")", ".", "Status", ".", "Final", "(", ")", "{", "ctl", ".", "State", "(", ")", ".", "Status", "=", "task", ".", "StatusAborted", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "abortInvocation", "marks", "some", "invocation", "as", "aborted", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "withController", "(", "c", "context", ".", "Context", ",", "jobID", "string", ",", "invID", "int64", ",", "action", "string", ",", "cb", "func", "(", "context", ".", "Context", ",", "*", "taskController", ")", "error", ")", "error", "{", "c", "=", "logging", ".", "SetField", "(", "c", ",", "\"", "\"", ",", "jobID", ")", "\n", "c", "=", "logging", ".", "SetField", "(", "c", ",", "\"", "\"", ",", "invID", ")", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "action", ")", "\n\n", "inv", ",", "err", ":=", "e", ".", "getInvocation", "(", "c", ",", "jobID", ",", "invID", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "case", "inv", ".", "Status", ".", "Final", "(", ")", ":", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "action", ",", "inv", ".", "Status", ")", "\n", "return", "nil", "\n", "}", "\n\n", "ctl", ",", "err", ":=", "controllerForInvocation", "(", "c", ",", "e", ",", "inv", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "cb", "(", "c", ",", "ctl", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "action", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "ctl", ".", "Save", "(", "c", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "withController", "fetches", "the", "invocation", "instantiates", "the", "task", "controller", "calls", "the", "callback", "and", "saves", "back", "the", "modified", "invocation", "state", "initiating", "all", "necessary", "engine", "transitions", "along", "the", "way", ".", "Does", "nothing", "and", "returns", "nil", "if", "the", "invocation", "is", "already", "in", "a", "final", "state", ".", "The", "callback", "is", "not", "called", "in", "this", "case", "at", "all", ".", "Skips", "saving", "the", "invocation", "if", "the", "callback", "returns", "non", "-", "nil", ".", "action", "is", "used", "exclusively", "for", "logging", ".", "It", "s", "a", "human", "readable", "cause", "of", "why", "the", "controller", "is", "instantiated", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "launchTask", "(", "c", "context", ".", "Context", ",", "inv", "*", "Invocation", ")", "error", "{", "assertNotInTransaction", "(", "c", ")", "\n\n", "// Grab the corresponding TaskManager to launch the task through it.", "ctl", ",", "err", ":=", "controllerForInvocation", "(", "c", ",", "e", ",", "inv", ")", "\n", "if", "err", "!=", "nil", "{", "// Note: controllerForInvocation returns both ctl and err on errors, with", "// ctl not fully initialized (but good enough for what's done below).", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "err", ")", "\n", "ctl", ".", "State", "(", ")", ".", "Status", "=", "task", ".", "StatusFailed", "\n", "return", "ctl", ".", "Save", "(", "c", ")", "\n", "}", "\n\n", "// Ask the manager to start the task. If it returns no errors, it should also", "// move the invocation out of an initial state (a failure to do so is a fatal", "// error). If it returns an error, the invocation is forcefully moved to", "// StatusRetrying or StatusFailed state (depending on whether the error is", "// transient or not and how many retries are left). In either case, invocation", "// never ends up in StatusStarting state.", "err", "=", "ctl", ".", "manager", ".", "LaunchTask", "(", "c", ",", "ctl", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "status", ":=", "ctl", ".", "State", "(", ")", ".", "Status", ";", "status", ".", "Initial", "(", ")", "&&", "err", "==", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "status", ")", "\n", "}", "\n", "if", "transient", ".", "Tag", ".", "In", "(", "err", ")", "&&", "inv", ".", "RetryCount", "+", "1", ">=", "invocationRetryLimit", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// The task must always end up in a non-initial state. Do it on behalf of the", "// controller if necessary.", "if", "ctl", ".", "State", "(", ")", ".", "Status", ".", "Initial", "(", ")", "{", "if", "transient", ".", "Tag", ".", "In", "(", "err", ")", "{", "// This invocation object will be reused for a retry later.", "ctl", ".", "State", "(", ")", ".", "Status", "=", "task", ".", "StatusRetrying", "\n", "}", "else", "{", "// The invocation has crashed with the fatal error.", "ctl", ".", "State", "(", ")", ".", "Status", "=", "task", ".", "StatusFailed", "\n", "}", "\n", "}", "\n\n", "// Add a notice into the invocation log that we'll attempt to retry.", "isRetrying", ":=", "ctl", ".", "State", "(", ")", ".", "Status", "==", "task", ".", "StatusRetrying", "\n", "if", "isRetrying", "{", "ctl", ".", "DebugLog", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// We MUST commit the state of the invocation. A failure to save the state", "// may cause the job state machine to get stuck. If we can't save it, we need", "// to retry the whole launch attempt from scratch (redoing all the work,", "// a properly implemented LaunchTask should be idempotent).", "if", "err", ":=", "ctl", ".", "Save", "(", "c", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Task retries happen via the task queue, need to explicitly trigger a retry", "// by returning a transient error.", "if", "isRetrying", "{", "return", "errRetryingLaunch", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "launchTask", "instantiates", "an", "invocation", "controller", "and", "calls", "its", "LaunchTask", "method", "saving", "the", "invocation", "state", "when", "its", "done", ".", "It", "returns", "a", "transient", "error", "if", "the", "launch", "attempt", "should", "be", "retried", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "execLaunchInvocationTask", "(", "c", "context", ".", "Context", ",", "tqTask", "proto", ".", "Message", ")", "error", "{", "msg", ":=", "tqTask", ".", "(", "*", "internal", ".", "LaunchInvocationTask", ")", "\n\n", "c", "=", "logging", ".", "SetField", "(", "c", ",", "\"", "\"", ",", "msg", ".", "JobId", ")", "\n", "c", "=", "logging", ".", "SetField", "(", "c", ",", "\"", "\"", ",", "msg", ".", "InvId", ")", "\n\n", "hdrs", ",", "err", ":=", "tq", ".", "RequestHeaders", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "retryCount", ":=", "hdrs", ".", "TaskExecutionCount", "// 0 for the first attempt", "\n", "if", "retryCount", "!=", "0", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "retryCount", "+", "1", ")", "\n", "}", "\n\n", "// Fetch up-to-date state of the invocation, verify we still need to start it.", "// Log that we are about to do it. We MUST write something to the datastore", "// before attempting the launch to make sure that if the datastore is in read", "// only mode (that happens), we don't spam LaunchTask retries when failing to", "// Save() the state in the end (better to fail now, before LaunchTask call).", "var", "skipLaunch", "bool", "\n", "var", "lastInvState", "Invocation", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "err", "=", "runTxn", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "skipLaunch", "=", "false", "// reset in case the transaction is retried", "\n\n", "// Grab up-to-date invocation state.", "inv", ":=", "Invocation", "{", "ID", ":", "msg", ".", "InvId", "}", "\n", "switch", "err", ":=", "ds", ".", "Get", "(", "c", ",", "&", "inv", ")", ";", "{", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "// This generally should not happen.", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "skipLaunch", "=", "true", "\n", "return", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "case", "!", "inv", ".", "Status", ".", "Initial", "(", ")", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "inv", ".", "Status", ")", "\n", "skipLaunch", "=", "true", "\n", "return", "nil", "\n", "}", "\n\n", "// The invocation is still starting or being retried now. Update its state", "// to indicate we are about to work with it. 'lastInvState' is later passed", "// to the task controller.", "lastInvState", "=", "inv", "\n", "lastInvState", ".", "RetryCount", "=", "retryCount", "\n", "lastInvState", ".", "MutationsCount", "++", "\n", "if", "retryCount", ">=", "invocationRetryLimit", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "lastInvState", ".", "debugLog", "(", "c", ",", "\"", "\"", ")", "\n", "lastInvState", ".", "Status", "=", "task", ".", "StatusFailed", "\n", "lastInvState", ".", "Finished", "=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "\n", "skipLaunch", "=", "true", "\n", "}", "else", "{", "lastInvState", ".", "debugLog", "(", "c", ",", "\"", "\"", ",", "retryCount", "+", "1", ")", "\n", "}", "\n\n", "// Make sure to trigger all necessary side effects, particularly important", "// if the invocation was moved to Failed state above.", "if", "err", ":=", "e", ".", "invChanging", "(", "c", ",", "&", "inv", ",", "&", "lastInvState", ",", "nil", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Store the updated invocation.", "lastInvState", ".", "trimDebugLog", "(", ")", "\n", "return", "transient", ".", "Tag", ".", "Apply", "(", "ds", ".", "Put", "(", "c", ",", "&", "lastInvState", ")", ")", "\n", "}", ")", "\n\n", "switch", "{", "case", "err", "!=", "nil", ":", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "case", "skipLaunch", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "e", ".", "launchTask", "(", "c", ",", "&", "lastInvState", ")", "\n", "}" ]

[ "execLaunchInvocationTask", "handles", "LaunchInvocationTask", ".", "It", "can", "be", "redelivered", "a", "bunch", "of", "times", "in", "case", "the", "invocation", "fails", "to", "start", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "execTimerTask", "(", "c", "context", ".", "Context", ",", "tqTask", "proto", ".", "Message", ")", "error", "{", "msg", ":=", "tqTask", ".", "(", "*", "internal", ".", "TimerTask", ")", "\n", "timer", ":=", "msg", ".", "Timer", "\n", "action", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "timer", ".", "Title", ",", "timer", ".", "Id", ")", "\n\n", "return", "e", ".", "withController", "(", "c", ",", "msg", ".", "JobId", ",", "msg", ".", "InvId", ",", "action", ",", "func", "(", "c", "context", ".", "Context", ",", "ctl", "*", "taskController", ")", "error", "{", "// Pop the timer from the pending set, if it is still there. Return a fatal", "// error if it isn't to stop this task from being redelivered.", "switch", "consumed", ",", "err", ":=", "ctl", ".", "consumeTimer", "(", "timer", ".", "Id", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "!", "consumed", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "timer", ".", "Id", ")", "\n", "}", "\n\n", "// Let the task manager handle the timer. It may add new timers.", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "timer", ".", "Title", ",", "timer", ".", "Id", ")", "\n", "err", ":=", "ctl", ".", "manager", ".", "HandleTimer", "(", "c", ",", "ctl", ",", "timer", ".", "Title", ",", "timer", ".", "Payload", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "return", "nil", "// success! save the invocation", "\n", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "return", "err", "// ask for redelivery on transient errors, don't touch the invocation", "\n", "}", "\n\n", "// On fatal errors, move the invocation to failed state (if not already).", "if", "ctl", ".", "State", "(", ")", ".", "Status", "!=", "task", ".", "StatusFailed", "{", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "err", ")", "\n", "ctl", ".", "State", "(", ")", ".", "Status", "=", "task", ".", "StatusFailed", "\n", "}", "\n\n", "// Need to save the invocation, even on fatal errors (to indicate that the", "// timer has been consumed). So return nil.", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "execTimerTask", "corresponds", "to", "a", "tick", "of", "a", "timer", "added", "via", "AddTimer", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "kickTriageLater", "(", "c", "context", ".", "Context", ",", "jobID", "string", ",", "delay", "time", ".", "Duration", ")", "error", "{", "c", "=", "logging", ".", "SetField", "(", "c", ",", "\"", "\"", ",", "jobID", ")", "\n", "return", "e", ".", "cfg", ".", "Dispatcher", ".", "AddTask", "(", "c", ",", "&", "tq", ".", "Task", "{", "Payload", ":", "&", "internal", ".", "KickTriageTask", "{", "JobId", ":", "jobID", "}", ",", "Delay", ":", "delay", ",", "}", ")", "\n", "}" ]

[ "kickTriageLater", "schedules", "a", "triage", "to", "be", "kicked", "later", ".", "Unlike", "kickTriageNow", "this", "just", "posts", "a", "single", "TQ", "task", "and", "thus", "can", "be", "used", "inside", "transactions", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "execKickTriageTask", "(", "c", "context", ".", "Context", ",", "tqTask", "proto", ".", "Message", ")", "error", "{", "return", "e", ".", "kickTriageNow", "(", "c", ",", "tqTask", ".", "(", "*", "internal", ".", "KickTriageTask", ")", ".", "JobId", ")", "\n", "}" ]

[ "execKickTriageTask", "handles", "delayed", "KickTriageTask", "by", "scheduling", "a", "triage", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "handlePubSubMessage", "(", "c", "context", ".", "Context", ",", "msg", "*", "pubsub", ".", "PubsubMessage", ")", "error", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "msg", ".", "MessageId", ")", "\n\n", "// Extract Job and Invocation ID from validated auth_token.", "var", "jobID", "string", "\n", "var", "invID", "int64", "\n", "data", ",", "err", ":=", "pubsubAuthToken", ".", "Validate", "(", "c", ",", "msg", ".", "Attributes", "[", "\"", "\"", "]", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n", "jobID", "=", "data", "[", "\"", "\"", "]", "\n", "if", "invID", ",", "err", "=", "strconv", ".", "ParseInt", "(", "data", "[", "\"", "\"", "]", ",", "10", ",", "64", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "data", "[", "\"", "\"", "]", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Hand the message to the controller.", "action", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "msg", ".", "MessageId", ")", "\n", "return", "e", ".", "withController", "(", "c", ",", "jobID", ",", "invID", ",", "action", ",", "func", "(", "c", "context", ".", "Context", ",", "ctl", "*", "taskController", ")", "error", "{", "err", ":=", "ctl", ".", "manager", ".", "HandleNotification", "(", "c", ",", "ctl", ",", "msg", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "return", "nil", "// success! save the invocation", "\n", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", "||", "tq", ".", "Retry", ".", "In", "(", "err", ")", ":", "return", "err", "// ask for redelivery on transient errors, don't touch the invocation", "\n", "}", "\n", "// On fatal errors, move the invocation to failed state (if not already).", "if", "ctl", ".", "State", "(", ")", ".", "Status", "!=", "task", ".", "StatusFailed", "{", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "err", ")", "\n", "ctl", ".", "State", "(", ")", ".", "Status", "=", "task", ".", "StatusFailed", "\n", "}", "\n", "return", "nil", "// need to save the invocation, even on fatal errors", "\n", "}", ")", "\n", "}" ]

[ "handlePubSubMessage", "routes", "the", "pubsub", "message", "to", "the", "invocation", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "genTopicAndSubNames", "(", "c", "context", ".", "Context", ",", "manager", ",", "publisher", "string", ")", "(", "topic", "string", ",", "sub", "string", ")", "{", "// Avoid accidental override of the topic when running on dev server.", "prefix", ":=", "\"", "\"", "\n", "if", "info", ".", "IsDevAppServer", "(", "c", ")", "{", "prefix", "=", "\"", "\"", "\n", "}", "\n\n", "// Each publisher gets its own topic (and subscription), so it's clearer from", "// logs and PubSub console who's calling what. PubSub topics can't have \"@\" in", "// them, so replace \"@\" with \"~\". URL encoding could have been used too, but", "// Cloud Console confuses %40 with its own URL encoding and doesn't display", "// all pages correctly.", "id", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "prefix", ",", "manager", ",", "strings", ".", "Replace", "(", "publisher", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", ")", "\n\n", "appID", ":=", "info", ".", "AppID", "(", "c", ")", "\n", "topic", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "appID", ",", "id", ")", "\n", "sub", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "appID", ",", "id", ")", "\n", "return", "\n", "}" ]

[ "genTopicAndSubNames", "derives", "PubSub", "topic", "and", "subscription", "names", "to", "use", "for", "notifications", "from", "given", "publisher", "." ]

[ "func", "(", "e", "*", "engineImpl", ")", "prepareTopic", "(", "c", "context", ".", "Context", ",", "params", "*", "topicParams", ")", "(", "topic", "string", ",", "tok", "string", ",", "err", "error", ")", "{", "// If given URL, ask the service for name of its default service account.", "// FetchServiceInfo implements efficient cache internally, so it's fine to", "// call it often.", "if", "strings", ".", "HasPrefix", "(", "params", ".", "publisher", ",", "\"", "\"", ")", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "params", ".", "publisher", ")", "\n", "serviceInfo", ",", "err", ":=", "signing", ".", "FetchServiceInfoFromLUCIService", "(", "c", ",", "params", ".", "publisher", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "params", ".", "publisher", ",", "err", ")", "\n", "return", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "params", ".", "publisher", ",", "serviceInfo", ".", "ServiceAccountName", ")", "\n", "params", ".", "publisher", "=", "serviceInfo", ".", "ServiceAccountName", "\n", "}", "\n\n", "topic", ",", "sub", ":=", "e", ".", "genTopicAndSubNames", "(", "c", ",", "params", ".", "manager", ".", "Name", "(", ")", ",", "params", ".", "publisher", ")", "\n\n", "// Put same parameters in push URL to make them visible in logs. On dev server", "// use pull based subscription, since localhost push URL is not valid.", "pushURL", ":=", "\"", "\"", "\n", "if", "!", "info", ".", "IsDevAppServer", "(", "c", ")", "{", "urlParams", ":=", "url", ".", "Values", "{", "}", "\n", "urlParams", ".", "Add", "(", "\"", "\"", ",", "params", ".", "manager", ".", "Name", "(", ")", ")", "\n", "urlParams", ".", "Add", "(", "\"", "\"", ",", "params", ".", "publisher", ")", "\n", "pushURL", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "info", ".", "DefaultVersionHostname", "(", "c", ")", ",", "e", ".", "cfg", ".", "PubSubPushPath", ",", "urlParams", ".", "Encode", "(", ")", ")", "\n", "}", "\n\n", "// Create and configure the topic. Do it only once.", "err", "=", "e", ".", "opsCache", ".", "Do", "(", "c", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "topic", ")", ",", "func", "(", ")", "error", "{", "if", "e", ".", "configureTopic", "!=", "nil", "{", "return", "e", ".", "configureTopic", "(", "c", ",", "topic", ",", "sub", ",", "pushURL", ",", "params", ".", "publisher", ")", "\n", "}", "\n", "return", "configureTopic", "(", "c", ",", "topic", ",", "sub", ",", "pushURL", ",", "params", ".", "publisher", ",", "\"", "\"", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// Encode full invocation identifier (job key + invocation ID) into HMAC", "// protected token.", "tok", ",", "err", "=", "pubsubAuthToken", ".", "Generate", "(", "c", ",", "nil", ",", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "params", ".", "jobID", ",", "\"", "\"", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "params", ".", "invID", ")", ",", "}", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "topic", ",", "tok", ",", "nil", "\n", "}" ]

[ "prepareTopic", "creates", "a", "pubsub", "topic", "that", "can", "be", "used", "to", "pass", "task", "related", "messages", "back", "to", "the", "task", ".", "Manager", "that", "handles", "the", "task", ".", "It", "returns", "full", "topic", "name", "as", "well", "as", "a", "token", "that", "securely", "identifies", "the", "task", ".", "It", "should", "be", "put", "into", "auth_token", "attribute", "of", "PubSub", "messages", "by", "whoever", "publishes", "them", "." ]

[ "func", "EnsureFile", "(", "ctx", "context", ".", "Context", ",", "fs", "FileSystem", ",", "path", "string", ",", "content", "io", ".", "Reader", ")", "error", "{", "return", "fs", ".", "EnsureFile", "(", "ctx", ",", "path", ",", "func", "(", "f", "*", "os", ".", "File", ")", "error", "{", "_", ",", "err", ":=", "io", ".", "Copy", "(", "f", ",", "content", ")", "\n", "return", "err", "\n", "}", ")", "\n", "}" ]

[ "EnsureFile", "creates", "a", "file", "with", "the", "given", "content", ".", "It", "will", "create", "full", "directory", "path", "to", "the", "file", "if", "necessary", "." ]

[ "func", "(", "f", "*", "fsImpl", ")", "moveToTrash", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "string", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "f", ".", "trash", ",", "0777", ")", ";", "err", "!=", "nil", "{", "logging", ".", "Warningf", "(", "ctx", ",", "\"", "\"", ",", "f", ".", "trash", ",", "err", ")", "\n", "return", "\"", "\"", "\n", "}", "\n", "trashed", ":=", "filepath", ".", "Join", "(", "f", ".", "trash", ",", "pseudoRand", "(", ")", ")", "\n", "if", "err", ":=", "atomicRename", "(", "path", ",", "trashed", ")", ";", "err", "!=", "nil", "{", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "logging", ".", "Warningf", "(", "ctx", ",", "\"", "\"", ",", "path", ",", "trashed", ",", "err", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}", "\n", "return", "trashed", "\n", "}" ]

[ "moveToTrash", "is", "best", "-", "effort", "function", "to", "move", "file", "or", "dir", "to", "trash", ".", "It", "returns", "path", "to", "a", "moved", "file", "in", "trash", "or", "empty", "string", "if", "it", "can", "t", "be", "done", "." ]

[ "func", "(", "f", "*", "fsImpl", ")", "cleanupTrashedFile", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "error", "{", "if", "filepath", ".", "Dir", "(", "path", ")", "!=", "f", ".", "trash", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "err", ":=", "os", ".", "RemoveAll", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Debugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "cleanupTrashedFile", "is", "best", "-", "effort", "function", "to", "remove", "a", "trashed", "file", "or", "dir", ".", "Logs", "errors", "." ]

[ "func", "pseudoRand", "(", ")", "string", "{", "ts", ":=", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", "\n", "lastUsedTimeLock", ".", "Lock", "(", ")", "\n", "if", "ts", "<=", "lastUsedTime", "{", "ts", "=", "lastUsedTime", "+", "1", "\n", "}", "\n", "lastUsedTime", "=", "ts", "\n", "lastUsedTimeLock", ".", "Unlock", "(", ")", "\n\n", "// Hash the state to get a smaller pseudorandom string.", "h", ":=", "sha256", ".", "New", "(", ")", "\n", "fmt", ".", "Fprintf", "(", "h", ",", "\"", "\"", ",", "os", ".", "Getpid", "(", ")", ",", "ts", ")", "\n", "sum", ":=", "h", ".", "Sum", "(", "nil", ")", "\n", "digest", ":=", "base64", ".", "RawURLEncoding", ".", "EncodeToString", "(", "sum", ")", "\n", "return", "digest", "[", ":", "12", "]", "\n", "}" ]

[ "pseudoRand", "returns", "random", "enough", "string", "that", "can", "be", "used", "in", "file", "system", "paths", "of", "temp", "files", "." ]

[ "func", "createFile", "(", "path", "string", ",", "write", "func", "(", "*", "os", ".", "File", ")", "error", ")", "(", "err", "error", ")", "{", "file", ",", "err", ":=", "os", ".", "Create", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "closeErr", ":=", "file", ".", "Close", "(", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "closeErr", "\n", "}", "\n", "}", "(", ")", "\n", "return", "write", "(", "file", ")", "\n", "}" ]

[ "createFile", "creates", "a", "file", "and", "calls", "the", "function", "to", "write", "file", "content", ".", "Does", "NOT", "cleanup", "the", "file", "if", "something", "fails", "midway", "." ]

[ "func", "MakeGlob", "(", "glob", "string", ")", "(", "Glob", ",", "error", ")", "{", "g", ":=", "Glob", "(", "glob", ")", "\n", "if", "err", ":=", "g", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "g", ",", "nil", "\n", "}" ]

[ "MakeGlob", "ensures", "glob", "string", "looks", "like", "a", "valid", "identity", "glob", "and", "returns", "it", "as", "Glob", "value", "." ]

[ "func", "(", "g", "Glob", ")", "Validate", "(", ")", "error", "{", "chunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "g", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "g", ")", "\n", "}", "\n", "if", "knownKinds", "[", "Kind", "(", "chunks", "[", "0", "]", ")", "]", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "chunks", "[", "0", "]", ")", "\n", "}", "\n", "if", "chunks", "[", "1", "]", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "cache", ".", "translate", "(", "chunks", "[", "1", "]", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "chunks", "[", "1", "]", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "that", "the", "identity", "glob", "string", "is", "well", "-", "formed", "." ]

[ "func", "(", "g", "Glob", ")", "Kind", "(", ")", "Kind", "{", "chunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "g", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "Anonymous", "\n", "}", "\n", "return", "Kind", "(", "chunks", "[", "0", "]", ")", "\n", "}" ]

[ "Kind", "returns", "identity", "glob", "kind", ".", "If", "identity", "glob", "string", "is", "invalid", "returns", "Anonymous", "." ]

[ "func", "(", "g", "Glob", ")", "Pattern", "(", ")", "string", "{", "chunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "g", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "chunks", "[", "1", "]", "\n", "}" ]

[ "Pattern", "returns", "a", "pattern", "part", "of", "the", "identity", "glob", ".", "If", "the", "identity", "glob", "string", "is", "invalid", "returns", "empty", "string", "." ]

[ "func", "(", "g", "Glob", ")", "Match", "(", "id", "Identity", ")", "bool", "{", "globChunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "g", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "globChunks", ")", "!=", "2", "||", "knownKinds", "[", "Kind", "(", "globChunks", "[", "0", "]", ")", "]", "==", "nil", "{", "return", "false", "\n", "}", "\n", "globKind", ":=", "globChunks", "[", "0", "]", "\n", "pattern", ":=", "globChunks", "[", "1", "]", "\n\n", "idChunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "id", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "idChunks", ")", "!=", "2", "||", "knownKinds", "[", "Kind", "(", "idChunks", "[", "0", "]", ")", "]", "==", "nil", "{", "return", "false", "\n", "}", "\n", "idKind", ":=", "idChunks", "[", "0", "]", "\n", "name", ":=", "idChunks", "[", "1", "]", "\n\n", "if", "idKind", "!=", "globKind", "{", "return", "false", "\n", "}", "\n", "if", "strings", ".", "ContainsRune", "(", "name", ",", "'\\n'", ")", "{", "return", "false", "\n", "}", "\n\n", "re", ",", "err", ":=", "cache", ".", "translate", "(", "pattern", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "re", ".", "MatchString", "(", "name", ")", "\n", "}" ]

[ "Match", "returns", "true", "if", "glob", "matches", "an", "identity", ".", "If", "identity", "string", "or", "identity", "glob", "string", "are", "invalid", "returns", "false", "." ]

[ "func", "(", "c", "*", "patternCache", ")", "translate", "(", "pat", "string", ")", "(", "*", "regexp", ".", "Regexp", ",", "error", ")", "{", "c", ".", "RLock", "(", ")", "\n", "val", ",", "ok", ":=", "c", ".", "cache", "[", "pat", "]", "\n", "c", ".", "RUnlock", "(", ")", "\n", "if", "ok", "{", "return", "val", ".", "re", ",", "val", ".", "err", "\n", "}", "\n\n", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "if", "val", ",", "ok", ":=", "c", ".", "cache", "[", "pat", "]", ";", "ok", "{", "return", "val", ".", "re", ",", "val", ".", "err", "\n", "}", "\n\n", "if", "c", ".", "cache", "==", "nil", "||", "len", "(", "c", ".", "cache", ")", ">", "500", "{", "c", ".", "cache", "=", "map", "[", "string", "]", "cacheEntry", "{", "}", "\n", "}", "\n\n", "var", "re", "*", "regexp", ".", "Regexp", "\n", "reStr", ",", "err", ":=", "translate", "(", "pat", ")", "\n", "if", "err", "==", "nil", "{", "re", ",", "err", "=", "regexp", ".", "Compile", "(", "reStr", ")", "\n", "}", "\n\n", "c", ".", "cache", "[", "pat", "]", "=", "cacheEntry", "{", "re", ",", "err", "}", "\n", "return", "re", ",", "err", "\n", "}" ]

[ "translate", "grabs", "converted", "regexp", "from", "cache", "or", "calls", "translate", "to", "get", "it", "." ]

[ "func", "translate", "(", "pat", "string", ")", "(", "string", ",", "error", ")", "{", "res", ":=", "\"", "\"", "\n", "for", "_", ",", "runeVal", ":=", "range", "pat", "{", "switch", "runeVal", "{", "case", "'\\n'", ":", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "case", "'*'", ":", "res", "+=", "\"", "\"", "\n", "default", ":", "res", "+=", "regexp", ".", "QuoteMeta", "(", "string", "(", "runeVal", ")", ")", "\n", "}", "\n", "}", "\n", "return", "res", "+", "\"", "\"", ",", "nil", "\n", "}" ]

[ "translate", "converts", "glob", "pattern", "to", "a", "regular", "expression", "string", "." ]

[ "func", "(", "*", "Service", ")", "ListRacks", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "ListRacksRequest", ")", "(", "*", "crimson", ".", "ListRacksResponse", ",", "error", ")", "{", "racks", ",", "err", ":=", "listRacks", "(", "c", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "crimson", ".", "ListRacksResponse", "{", "Racks", ":", "racks", ",", "}", ",", "nil", "\n", "}" ]

[ "ListRacks", "handles", "a", "request", "to", "retrieve", "racks", "." ]

[ "func", "listRacks", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "ListRacksRequest", ")", "(", "[", "]", "*", "crimson", ".", "Rack", ",", "error", ")", "{", "stmt", ":=", "squirrel", ".", "Select", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ".", "From", "(", "\"", "\"", ")", ".", "LeftJoin", "(", "\"", "\"", ")", ".", "LeftJoin", "(", "\"", "\"", ")", ".", "Where", "(", "\"", "\"", ")", "\n", "stmt", "=", "selectInString", "(", "stmt", ",", "\"", "\"", ",", "req", ".", "Names", ")", "\n", "stmt", "=", "selectInString", "(", "stmt", ",", "\"", "\"", ",", "req", ".", "Datacenters", ")", "\n", "stmt", "=", "selectInString", "(", "stmt", ",", "\"", "\"", ",", "req", ".", "Kvms", ")", "\n", "query", ",", "args", ",", "err", ":=", "stmt", ".", "ToSql", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "db", ":=", "database", ".", "Get", "(", "c", ")", "\n", "rows", ",", "err", ":=", "db", ".", "QueryContext", "(", "c", ",", "query", ",", "args", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "var", "racks", "[", "]", "*", "crimson", ".", "Rack", "\n", "for", "rows", ".", "Next", "(", ")", "{", "rack", ":=", "&", "crimson", ".", "Rack", "{", "}", "\n", "var", "kvm", "sql", ".", "NullString", "\n", "if", "err", "=", "rows", ".", "Scan", "(", "&", "rack", ".", "Name", ",", "&", "rack", ".", "Description", ",", "&", "rack", ".", "State", ",", "&", "rack", ".", "Datacenter", ",", "&", "kvm", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "kvm", ".", "Valid", "{", "rack", ".", "Kvm", "=", "kvm", ".", "String", "\n", "}", "\n", "racks", "=", "append", "(", "racks", ",", "rack", ")", "\n", "}", "\n", "return", "racks", ",", "nil", "\n", "}" ]

[ "listRacks", "returns", "a", "slice", "of", "racks", "in", "the", "database", "." ]

[ "func", "GetVersionFile", "(", "exePath", "string", ")", "string", "{", "// <root>/.versions/exename.cipd_version", "return", "filepath", ".", "Join", "(", "filepath", ".", "Dir", "(", "exePath", ")", ",", "\"", "\"", ",", "filepath", ".", "Base", "(", "exePath", ")", "+", "\"", "\"", ")", "\n", "}" ]

[ "GetVersionFile", "returns", "the", "path", "to", "the", "version", "file", "corresponding", "to", "the", "provided", "exe", ".", "This", "isn", "t", "typically", "needed", "but", "can", "be", "useful", "for", "debugging", "." ]

[ "func", "readVersionFile", "(", "path", "string", ")", "(", "Info", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "err", "=", "nil", "\n", "}", "\n", "return", "Info", "{", "}", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "out", ":=", "Info", "{", "}", "\n", "if", "err", "=", "json", ".", "NewDecoder", "(", "f", ")", ".", "Decode", "(", "&", "out", ")", ";", "err", "!=", "nil", "{", "return", "Info", "{", "}", ",", "err", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "readVersionFile", "returns", "parsed", "version", "file", ".", "Returns", "empty", "struct", "and", "nil", "if", "it", "is", "missing", "error", "if", "it", "can", "t", "be", "read", "." ]

[ "func", "IsSubpath", "(", "path", ",", "root", "string", ")", "bool", "{", "path", ",", "err", ":=", "filepath", ".", "Abs", "(", "filepath", ".", "Clean", "(", "path", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "root", ",", "err", "=", "filepath", ".", "Abs", "(", "filepath", ".", "Clean", "(", "root", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "if", "root", "==", "path", "{", "return", "true", "\n", "}", "\n", "if", "root", "[", "len", "(", "root", ")", "-", "1", "]", "!=", "filepath", ".", "Separator", "{", "root", "+=", "string", "(", "filepath", ".", "Separator", ")", "\n", "}", "\n", "return", "strings", ".", "HasPrefix", "(", "path", ",", "root", ")", "\n", "}" ]

[ "IsSubpath", "returns", "true", "if", "path", "is", "root", "or", "is", "inside", "a", "subdirectory", "of", "root", ".", "Both", "path", "and", "root", "should", "be", "given", "as", "a", "native", "paths", ".", "If", "any", "of", "paths", "can", "t", "be", "converted", "to", "an", "absolute", "path", "returns", "false", "." ]

[ "func", "(", "g", "*", "GraphData", ")", "ToQuery", "(", ")", "(", "ret", "*", "GraphQuery", ")", "{", "partials", ":=", "map", "[", "string", "]", "[", "]", "uint32", "{", "}", "\n", "for", "qid", ",", "qst", ":=", "range", "g", ".", "Quests", "{", "// TODO(iannucci): handle q.Partial explicitly?", "for", "aid", ",", "atmpt", ":=", "range", "qst", ".", "Attempts", "{", "if", "atmpt", ".", "Partial", ".", "Any", "(", ")", "{", "partials", "[", "qid", "]", "=", "append", "(", "partials", "[", "qid", "]", ",", "aid", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "partials", ")", ">", "0", "{", "ret", "=", "&", "GraphQuery", "{", "AttemptList", ":", "NewAttemptList", "(", "partials", ")", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "ToQuery", "generates", "a", "new", "GraphQuery", ".", "This", "generates", "a", "GraphQuery", "that", "queries", "for", "any", "Attempts", "which", "are", "marked", "as", "Partial", "in", "the", "current", "GraphData", "." ]

[ "func", "(", "a", "*", "ArchiveOptions", ")", "Init", "(", ")", "{", "a", ".", "Blacklist", "=", "stringlistflag", ".", "Flag", "{", "}", "\n", "a", ".", "PathVariables", "=", "map", "[", "string", "]", "string", "{", "}", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "a", ".", "PathVariables", "[", "\"", "\"", "]", "=", "\"", "\"", "\n", "}", "else", "{", "a", ".", "PathVariables", "[", "\"", "\"", "]", "=", "\"", "\"", "\n", "}", "\n", "a", ".", "ExtraVariables", "=", "map", "[", "string", "]", "string", "{", "}", "\n", "a", ".", "ConfigVariables", "=", "map", "[", "string", "]", "string", "{", "}", "\n", "}" ]

[ "Init", "initializes", "with", "non", "-", "nil", "values", "." ]

[ "func", "(", "a", "*", "ArchiveOptions", ")", "PostProcess", "(", "cwd", "string", ")", "{", "// Set default blacklist only if none is set.", "if", "len", "(", "a", ".", "Blacklist", ")", "==", "0", "{", "// This cannot be generalized as \".*\" as there is known use that require", "// a \".pki\" directory to be mapped.", "a", ".", "Blacklist", "=", "stringlistflag", ".", "Flag", "{", "// Temporary python files.", "\"", "\"", ",", "// Temporary vim files.", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "}", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "a", ".", "Isolate", ")", "{", "a", ".", "Isolate", "=", "filepath", ".", "Join", "(", "cwd", ",", "a", ".", "Isolate", ")", "\n", "}", "\n", "a", ".", "Isolate", "=", "filepath", ".", "Clean", "(", "a", ".", "Isolate", ")", "\n\n", "if", "!", "filepath", ".", "IsAbs", "(", "a", ".", "Isolated", ")", "{", "a", ".", "Isolated", "=", "filepath", ".", "Join", "(", "cwd", ",", "a", ".", "Isolated", ")", "\n", "}", "\n", "a", ".", "Isolated", "=", "filepath", ".", "Clean", "(", "a", ".", "Isolated", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "a", ".", "PathVariables", "{", "// This is due to a Windows + GYP specific issue, where double-quoted paths", "// would get mangled in a way that cannot be resolved unless a space is", "// injected.", "a", ".", "PathVariables", "[", "k", "]", "=", "strings", ".", "TrimSpace", "(", "v", ")", "\n", "}", "\n", "}" ]

[ "PostProcess", "post", "-", "processes", "the", "flags", "to", "fix", "any", "compatibility", "issue", "." ]

[ "func", "AdminServerWithACL", "(", "e", "engine", ".", "EngineInternal", ",", "c", "catalog", ".", "Catalog", ",", "adminGroup", "string", ")", "internal", ".", "AdminServer", "{", "return", "&", "internal", ".", "DecoratedAdmin", "{", "Service", ":", "&", "adminServer", "{", "Engine", ":", "e", ",", "Catalog", ":", "c", ",", "}", ",", "Prelude", ":", "func", "(", "c", "context", ".", "Context", ",", "methodName", "string", ",", "req", "proto", ".", "Message", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "caller", ":=", "auth", ".", "CurrentIdentity", "(", "c", ")", "\n", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "methodName", ",", "caller", ")", "\n", "switch", "yes", ",", "err", ":=", "auth", ".", "IsMember", "(", "c", ",", "adminGroup", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ")", "\n", "case", "!", "yes", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "PermissionDenied", ",", "\"", "\"", ")", "\n", "default", ":", "return", "c", ",", "nil", "\n", "}", "\n", "}", ",", "Postlude", ":", "func", "(", "c", "context", ".", "Context", ",", "methodName", "string", ",", "rsp", "proto", ".", "Message", ",", "err", "error", ")", "error", "{", "return", "grpcutil", ".", "GRPCifyAndLogErr", "(", "c", ",", "err", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "AdminServerWithACL", "returns", "AdminServer", "implementation", "that", "checks", "all", "callers", "are", "in", "the", "given", "administrator", "group", "." ]

[ "func", "(", "s", "*", "adminServer", ")", "GetDebugJobState", "(", "c", "context", ".", "Context", ",", "r", "*", "schedulerpb", ".", "JobRef", ")", "(", "resp", "*", "internal", ".", "DebugJobState", ",", "err", "error", ")", "{", "switch", "state", ",", "err", ":=", "s", ".", "Engine", ".", "GetDebugJobState", "(", "c", ",", "r", ".", "Project", "+", "\"", "\"", "+", "r", ".", "Job", ")", ";", "{", "case", "err", "==", "engine", ".", "ErrNoSuchJob", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ")", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "default", ":", "return", "&", "internal", ".", "DebugJobState", "{", "Enabled", ":", "state", ".", "Job", ".", "Enabled", ",", "Paused", ":", "state", ".", "Job", ".", "Paused", ",", "LastTriage", ":", "google", ".", "NewTimestamp", "(", "state", ".", "Job", ".", "LastTriage", ")", ",", "CronState", ":", "&", "internal", ".", "DebugJobState_CronState", "{", "Enabled", ":", "state", ".", "Job", ".", "Cron", ".", "Enabled", ",", "Generation", ":", "state", ".", "Job", ".", "Cron", ".", "Generation", ",", "LastRewind", ":", "google", ".", "NewTimestamp", "(", "state", ".", "Job", ".", "Cron", ".", "LastRewind", ")", ",", "LastTickWhen", ":", "google", ".", "NewTimestamp", "(", "state", ".", "Job", ".", "Cron", ".", "LastTick", ".", "When", ")", ",", "LastTickNonce", ":", "state", ".", "Job", ".", "Cron", ".", "LastTick", ".", "TickNonce", ",", "}", ",", "ManagerState", ":", "state", ".", "ManagerState", ",", "ActiveInvocations", ":", "state", ".", "Job", ".", "ActiveInvocations", ",", "FinishedInvocations", ":", "state", ".", "FinishedInvocations", ",", "RecentlyFinishedSet", ":", "state", ".", "RecentlyFinishedSet", ",", "PendingTriggersSet", ":", "state", ".", "PendingTriggersSet", ",", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "GetDebugJobState", "implements", "the", "corresponding", "RPC", "method", "." ]

[ "func", "(", "e", "*", "Job", ")", "IsEqual", "(", "other", "*", "Job", ")", "bool", "{", "return", "e", "==", "other", "||", "(", "e", ".", "JobID", "==", "other", ".", "JobID", "&&", "e", ".", "ProjectID", "==", "other", ".", "ProjectID", "&&", "e", ".", "Flavor", "==", "other", ".", "Flavor", "&&", "e", ".", "Enabled", "==", "other", ".", "Enabled", "&&", "e", ".", "Paused", "==", "other", ".", "Paused", "&&", "e", ".", "Revision", "==", "other", ".", "Revision", "&&", "e", ".", "RevisionURL", "==", "other", ".", "RevisionURL", "&&", "e", ".", "Schedule", "==", "other", ".", "Schedule", "&&", "e", ".", "LastTriage", ".", "Equal", "(", "other", ".", "LastTriage", ")", "&&", "e", ".", "Acls", ".", "Equal", "(", "&", "other", ".", "Acls", ")", "&&", "bytes", ".", "Equal", "(", "e", ".", "Task", ",", "other", ".", "Task", ")", "&&", "equalSortedLists", "(", "e", ".", "TriggeredJobIDs", ",", "other", ".", "TriggeredJobIDs", ")", "&&", "e", ".", "Cron", ".", "Equal", "(", "&", "other", ".", "Cron", ")", "&&", "bytes", ".", "Equal", "(", "e", ".", "TriggeringPolicyRaw", ",", "other", ".", "TriggeringPolicyRaw", ")", "&&", "equalInt64Lists", "(", "e", ".", "ActiveInvocations", ",", "other", ".", "ActiveInvocations", ")", "&&", "bytes", ".", "Equal", "(", "e", ".", "FinishedInvocationsRaw", ",", "other", ".", "FinishedInvocationsRaw", ")", ")", "\n", "}" ]

[ "IsEqual", "returns", "true", "iff", "e", "is", "equal", "to", "other", "." ]

[ "func", "(", "e", "*", "Job", ")", "MatchesDefinition", "(", "def", "catalog", ".", "Definition", ")", "bool", "{", "return", "e", ".", "JobID", "==", "def", ".", "JobID", "&&", "e", ".", "Flavor", "==", "def", ".", "Flavor", "&&", "e", ".", "Schedule", "==", "def", ".", "Schedule", "&&", "e", ".", "Acls", ".", "Equal", "(", "&", "def", ".", "Acls", ")", "&&", "bytes", ".", "Equal", "(", "e", ".", "Task", ",", "def", ".", "Task", ")", "&&", "bytes", ".", "Equal", "(", "e", ".", "TriggeringPolicyRaw", ",", "def", ".", "TriggeringPolicy", ")", "&&", "equalSortedLists", "(", "e", ".", "TriggeredJobIDs", ",", "def", ".", "TriggeredJobIDs", ")", "\n", "}" ]

[ "MatchesDefinition", "returns", "true", "if", "job", "definition", "in", "the", "entity", "matches", "the", "one", "specified", "by", "catalog", ".", "Definition", "struct", "." ]

[ "func", "(", "e", "*", "Job", ")", "CheckRole", "(", "c", "context", ".", "Context", ",", "role", "acl", ".", "Role", ")", "error", "{", "switch", "yep", ",", "err", ":=", "e", ".", "Acls", ".", "CallerHasRole", "(", "logging", ".", "SetField", "(", "c", ",", "\"", "\"", ",", "e", ".", "JobID", ")", ",", "role", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "!", "yep", ":", "return", "ErrNoPermission", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckRole", "returns", "nil", "if", "the", "caller", "has", "the", "given", "role", "or", "ErrNoPermission", "otherwise", ".", "May", "also", "return", "transient", "errors", "." ]

[ "func", "(", "s", "*", "invocationIDSet", ")", "Add", "(", "c", "context", ".", "Context", ",", "ids", "[", "]", "int64", ")", "error", "{", "items", ":=", "make", "(", "[", "]", "dsset", ".", "Item", ",", "len", "(", "ids", ")", ")", "\n", "for", "i", ",", "id", ":=", "range", "ids", "{", "items", "[", "i", "]", ".", "ID", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "return", "s", ".", "Set", ".", "Add", "(", "c", ",", "items", ")", "\n", "}" ]

[ "Add", "adds", "a", "bunch", "of", "invocation", "IDs", "to", "the", "set", "." ]

[ "func", "(", "s", "*", "invocationIDSet", ")", "ItemToInvID", "(", "i", "*", "dsset", ".", "Item", ")", "int64", "{", "id", ",", "_", ":=", "strconv", ".", "ParseInt", "(", "i", ".", "ID", ",", "10", ",", "64", ")", "\n", "return", "id", "\n", "}" ]

[ "ItemToInvID", "takes", "a", "dsset", ".", "Item", "and", "returns", "invocation", "ID", "stored", "there", "or", "0", "if", "it", "s", "malformed", "." ]

[ "func", "(", "s", "*", "triggersSet", ")", "Add", "(", "c", "context", ".", "Context", ",", "triggers", "[", "]", "*", "internal", ".", "Trigger", ")", "error", "{", "items", ":=", "make", "(", "[", "]", "dsset", ".", "Item", ",", "0", ",", "len", "(", "triggers", ")", ")", "\n", "for", "_", ",", "t", ":=", "range", "triggers", "{", "blob", ",", "err", ":=", "proto", ".", "Marshal", "(", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "items", "=", "append", "(", "items", ",", "dsset", ".", "Item", "{", "ID", ":", "t", ".", "Id", ",", "Value", ":", "blob", ",", "}", ")", "\n", "}", "\n", "return", "s", ".", "Set", ".", "Add", "(", "c", ",", "items", ")", "\n", "}" ]

[ "Add", "adds", "triggers", "to", "the", "set", "." ]

[ "func", "validateUpdateMask", "(", "m", "*", "field_mask", ".", "FieldMask", ")", "error", "{", "switch", "{", "case", "m", "==", "nil", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "len", "(", "m", ".", "Paths", ")", "==", "0", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "// Path names must be unique.", "// Keep records of ones we've already seen.", "paths", ":=", "stringset", ".", "New", "(", "len", "(", "m", ".", "Paths", ")", ")", "\n", "for", "_", ",", "path", ":=", "range", "m", ".", "Paths", "{", "if", "!", "paths", ".", "Add", "(", "path", ")", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "valdiateUpdateMask", "validates", "the", "given", "update", "mask", "." ]

[ "func", "GetFailureCollector", "(", "th", "*", "starlark", ".", "Thread", ")", "*", "FailureCollector", "{", "fc", ",", "_", ":=", "th", ".", "Local", "(", "failSlotKey", ")", ".", "(", "*", "FailureCollector", ")", "\n", "return", "fc", "\n", "}" ]

[ "GetFailureCollector", "returns", "a", "failure", "collector", "installed", "in", "the", "thread", "." ]

[ "func", "(", "fc", "*", "FailureCollector", ")", "Install", "(", "t", "*", "starlark", ".", "Thread", ")", "{", "t", ".", "SetLocal", "(", "failSlotKey", ",", "fc", ")", "\n", "}" ]

[ "Install", "installs", "this", "failure", "collector", "into", "the", "thread", "." ]

[ "func", "getMetadataImpl", "(", "c", "context", ".", "Context", ",", "prefix", "string", ")", "(", "[", "]", "*", "api", ".", "PrefixMetadata", ",", "[", "]", "*", "packageACL", ",", "error", ")", "{", "prefix", ",", "err", ":=", "common", ".", "ValidatePackagePrefix", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Grab all subprefixes, i.e. [\"a\", \"a/b\", \"a/b/c\"]", "var", "pfxs", "[", "]", "string", "\n", "for", "i", ",", "ch", ":=", "range", "prefix", "{", "if", "ch", "==", "'/'", "{", "pfxs", "=", "append", "(", "pfxs", ",", "prefix", "[", ":", "i", "]", ")", "\n", "}", "\n", "}", "\n", "pfxs", "=", "append", "(", "pfxs", ",", "prefix", ")", "\n\n", "// Start with the root metadata.", "out", ":=", "make", "(", "[", "]", "*", "api", ".", "PrefixMetadata", ",", "0", ",", "len", "(", "pfxs", ")", "+", "1", ")", "\n", "out", "=", "append", "(", "out", ",", "rootMetadata", "(", ")", ")", "\n\n", "// And finish with it if nothing else is requested.", "if", "len", "(", "pfxs", ")", "==", "0", "{", "return", "out", ",", "nil", ",", "nil", "\n", "}", "\n\n", "// Prepare the keys.", "ents", ":=", "make", "(", "[", "]", "*", "packageACL", ",", "0", ",", "len", "(", "pfxs", ")", "*", "len", "(", "legacyRoles", ")", ")", "\n", "for", "_", ",", "p", ":=", "range", "pfxs", "{", "ents", "=", "prefixACLs", "(", "c", ",", "p", ",", "ents", ")", "\n", "}", "\n\n", "// Fetch everything. ErrNoSuchEntity errors are fine, everything else is not.", "if", "err", "=", "datastore", ".", "Get", "(", "c", ",", "ents", ")", ";", "isInternalDSError", "(", "err", ")", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Combine the result into a bunch of PrefixMetadata structs.", "legLen", ":=", "len", "(", "legacyRoles", ")", "\n", "for", "i", ",", "pfx", ":=", "range", "pfxs", "{", "if", "md", ":=", "mergeIntoPrefixMetadata", "(", "c", ",", "pfx", ",", "ents", "[", "i", "*", "legLen", ":", "(", "i", "+", "1", ")", "*", "legLen", "]", ")", ";", "md", "!=", "nil", "{", "out", "=", "append", "(", "out", ",", "md", ")", "\n", "}", "\n", "}", "\n", "return", "out", ",", "ents", ",", "nil", "\n", "}" ]

[ "getMetadataImpl", "implements", "GetMetadata", ".", "As", "a", "bonus", "it", "returns", "all", "packageACL", "entities", "it", "fetched", ".", "This", "is", "used", "by", "VisitMetadata", "to", "avoid", "unnecessary", "refetches", "." ]

[ "func", "(", "legacyStorageImpl", ")", "VisitMetadata", "(", "c", "context", ".", "Context", ",", "prefix", "string", ",", "cb", "Visitor", ")", "error", "{", "prefix", ",", "err", ":=", "common", ".", "ValidatePackagePrefix", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Visit 'prefix' directly first, per VisitMetadata contract. There's a chance", "// we won't need to recurse deeper at all and can skip all expensive fetches.", "md", ",", "ents", ",", "err", ":=", "getMetadataImpl", "(", "c", ",", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "switch", "cont", ",", "err", ":=", "cb", "(", "prefix", ",", "md", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "!", "cont", ":", "return", "nil", "\n", "}", "\n\n", "// We'll have to recurse into metadata subtree after all. Unfortunately,", "// with legacy entity structure there's no way to efficiently fetch only", "// immediate children of 'prefix', so we fetch EVERYTHING in advance, building", "// a metadata graph for prefix/... in memory.", "gr", ":=", "metadataGraph", "{", "}", "\n", "gr", ".", "init", "(", "rootMetadata", "(", ")", ")", "\n\n", "// Seed this graph with already fetched entities. They'll be needed to derive", "// metadata inherited from 'prefix' and its parents when visiting nodes. For", "// example, the metadata graph when visiting prefix \"a/b\" may look like this:", "//", "// - \"a/b/c\"", "// /", "// ROOT - \"a\"- \"a/b\" -- \"a/b/d\"", "// \\", "// - \"a/b/e\"", "//", "// The traversal will be started form \"a/b\", but we still need the nodes", "// leading to the root to get all inherited metadata.", "gr", ".", "insert", "(", "c", ",", "ents", ")", "\n\n", "// Fetch each per-role subtree separately, they have different key prefixes.", "err", "=", "parallel", ".", "FanOutIn", "(", "func", "(", "tasks", "chan", "<-", "func", "(", ")", "error", ")", "{", "mu", ":=", "sync", ".", "Mutex", "{", "}", "\n", "for", "_", ",", "role", ":=", "range", "legacyRoles", "{", "role", ":=", "role", "\n", "tasks", "<-", "func", "(", ")", "error", "{", "listing", ",", "err", ":=", "listACLsByPrefix", "(", "c", ",", "role", ",", "prefix", ")", "\n", "if", "err", "==", "nil", "{", "mu", ".", "Lock", "(", ")", "\n", "gr", ".", "insert", "(", "c", ",", "listing", ")", "\n", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Make sure we have a path to 'prefix' before we freeze the graph. We need it", "// to start the traversal below. It may be missing if there's no metadata", "// attached to it and it has no children. This will naturally be handled by", "// 'traverse'.", "pfx", ":=", "gr", ".", "node", "(", "prefix", ")", "\n\n", "// Calculate all PrefixMetadata entries in the graph.", "gr", ".", "freeze", "(", "c", ")", "\n\n", "// Traverse the graph, but make sure to skip 'prefix' itself, we've already", "// visited it at the very beginning.", "return", "pfx", ".", "traverse", "(", "nil", ",", "func", "(", "n", "*", "metadataNode", ",", "md", "[", "]", "*", "api", ".", "PrefixMetadata", ")", "(", "cont", "bool", ",", "err", "error", ")", "{", "switch", "{", "case", "n", ".", "prefix", "==", "prefix", ":", "return", "true", ",", "nil", "\n", "case", "n", ".", "md", "==", "nil", ":", "return", "true", ",", "nil", "// an intermediary node with no metadata, look deeper", "\n", "default", ":", "return", "cb", "(", "n", ".", "prefix", ",", "md", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "VisitMetadata", "is", "part", "of", "Storage", "interface", "." ]

[ "func", "(", "legacyStorageImpl", ")", "UpdateMetadata", "(", "c", "context", ".", "Context", ",", "prefix", "string", ",", "cb", "func", "(", "m", "*", "api", ".", "PrefixMetadata", ")", "error", ")", "(", "*", "api", ".", "PrefixMetadata", ",", "error", ")", "{", "prefix", ",", "err", ":=", "common", ".", "ValidatePackagePrefix", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "prefix", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "var", "cbErr", "error", "// error from 'cb'", "\n", "var", "updated", "*", "api", ".", "PrefixMetadata", "// updated metadata to return", "\n\n", "err", "=", "datastore", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "cbErr", "=", "nil", "// reset in case the transaction is being retried", "\n", "updated", "=", "nil", "\n\n", "// Fetch the existing metadata.", "ents", ":=", "prefixACLs", "(", "c", ",", "prefix", ",", "nil", ")", "\n", "if", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "ents", ")", ";", "isInternalDSError", "(", "err", ")", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Convert it to PrefixMetadata object. This will be nil if there's no", "// existing metadata, in which case we construct the default metadata", "// with no fingerprint (to indicate it is new), see UpdateMetadata doc in", "// Storage interface.", "updated", "=", "mergeIntoPrefixMetadata", "(", "c", ",", "prefix", ",", "ents", ")", "\n", "if", "updated", "==", "nil", "{", "updated", "=", "&", "api", ".", "PrefixMetadata", "{", "Prefix", ":", "prefix", "}", "\n", "}", "\n\n", "// Let the callback update the metadata. Retain the old copy for diff later.", "before", ":=", "proto", ".", "Clone", "(", "updated", ")", ".", "(", "*", "api", ".", "PrefixMetadata", ")", "\n", "if", "cbErr", "=", "cb", "(", "updated", ")", ";", "cbErr", "!=", "nil", "{", "return", "cbErr", "\n", "}", "\n\n", "// Don't let the callback mess with the prefix or the fingerprint.", "updated", ".", "Prefix", "=", "before", ".", "Prefix", "\n", "updated", ".", "Fingerprint", "=", "before", ".", "Fingerprint", "\n", "if", "proto", ".", "Equal", "(", "before", ",", "updated", ")", "{", "return", "nil", "// no changes whatsoever, don't touch anything", "\n", "}", "\n\n", "// Apply changes to the datastore. This updates 'ents' to match the metadata", "// stored in 'updated'. We then rederive PrefixMetadata (including the new", "// fingerprint) from them. We do it this way (instead of calculating the", "// fingerprint using 'updated' directly), to be absolutely sure that the", "// fingerprint returned by GetMetadata after this transaction lands matches", "// the fingerprint we return from UpdateMetadata. In particular, the way", "// we store ACLs in legacy entities doesn't preserve order of Acls entries", "// in the proto, or order of principals inside Acls, so we need to", "// \"reformat\" the updated metadata before calculating its fingerprint.", "if", "err", ":=", "applyACLDiff", "(", "c", ",", "ents", ",", "updated", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "updated", "=", "mergeIntoPrefixMetadata", "(", "c", ",", "prefix", ",", "ents", ")", "\n", "return", "nil", "\n", "}", ",", "&", "datastore", ".", "TransactionOptions", "{", "XG", ":", "true", "}", ")", "\n\n", "switch", "{", "case", "cbErr", "!=", "nil", ":", "// The callback itself failed, need to return the error as is, as promised.", "return", "nil", ",", "cbErr", "\n", "case", "err", "!=", "nil", ":", "// All other errors are from the datastore, consider them transient.", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "case", "updated", "==", "nil", "||", "updated", ".", "Fingerprint", "==", "\"", "\"", ":", "// This happens if there's no existing metadata and the callback didn't", "// create it. Return nil to indicate that the metadata is still missing.", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "updated", ",", "nil", "\n", "}" ]

[ "UpdateMetadata", "is", "part", "of", "Storage", "interface", ".", "It", "assembles", "prefix", "metadata", "from", "a", "bunch", "of", "packageACL", "entities", "passes", "it", "to", "the", "callback", "for", "modification", "then", "deconstructs", "it", "back", "into", "a", "bunch", "of", "packageACL", "entities", "to", "be", "saved", "in", "the", "datastore", ".", "All", "done", "transactionally", "." ]

[ "func", "(", "e", "*", "packageACL", ")", "parseKey", "(", ")", "(", "role", ",", "prefix", "string", ",", "err", "error", ")", "{", "chunks", ":=", "strings", ".", "Split", "(", "e", ".", "ID", ",", "\"", "\"", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "ID", ")", "\n", "}", "\n", "role", "=", "chunks", "[", "0", "]", "\n", "if", "_", ",", "ok", ":=", "legacyRoleMap", "[", "role", "]", ";", "!", "ok", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "ID", ")", "\n", "}", "\n", "prefix", ",", "err", "=", "common", ".", "ValidatePackagePrefix", "(", "chunks", "[", "1", "]", ")", "\n", "if", "err", "!=", "nil", "||", "prefix", "==", "\"", "\"", "{", "// note: there's no ACLs for root in the datastore", "return", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "ID", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "parseKey", "parses", "the", "entity", "key", "into", "its", "components", "validating", "them", ".", "On", "success", "role", "is", "one", "of", "legacyRoles", "and", "prefix", "is", "non", "-", "empty", "valid", "prefix", "." ]

[ "func", "isInternalDSError", "(", "err", "error", ")", "bool", "{", "if", "err", "==", "nil", "{", "return", "false", "\n", "}", "\n\n", "merr", ",", "_", ":=", "err", ".", "(", "errors", ".", "MultiError", ")", "\n", "if", "merr", "==", "nil", "{", "return", "true", "// an overall RPC error", "\n", "}", "\n\n", "for", "_", ",", "e", ":=", "range", "merr", "{", "if", "e", "!=", "nil", "&&", "e", "!=", "datastore", ".", "ErrNoSuchEntity", "{", "return", "true", "// some serious issues with this single entity", "\n", "}", "\n", "}", "\n\n", "return", "false", "// all suberrors are either nil or ErrNoSuchEntity", "\n", "}" ]

[ "isInternalDSError", "is", "true", "for", "datastore", "errors", "that", "aren", "t", "entirely", "ErrNoSuchEntity", "." ]

[ "func", "rootKey", "(", "c", "context", ".", "Context", ")", "*", "datastore", ".", "Key", "{", "return", "datastore", ".", "NewKey", "(", "c", ",", "\"", "\"", ",", "\"", "\"", ",", "0", ",", "nil", ")", "\n", "}" ]

[ "rootKey", "returns", "a", "key", "of", "the", "root", "entity", "that", "stores", "ACL", "hierarchy", "." ]

[ "func", "(", "n", "*", "metadataNode", ")", "child", "(", "name", "string", ")", "*", "metadataNode", "{", "if", "c", ",", "ok", ":=", "n", ".", "children", "[", "name", "]", ";", "ok", "{", "return", "c", "\n", "}", "\n", "n", ".", "assertNonFrozen", "(", ")", "\n", "if", "n", ".", "children", "==", "nil", "{", "n", ".", "children", "=", "make", "(", "map", "[", "string", "]", "*", "metadataNode", ",", "1", ")", "\n", "}", "\n", "c", ":=", "&", "metadataNode", "{", "parent", ":", "n", ",", "acls", ":", "make", "(", "[", "]", "*", "packageACL", ",", "len", "(", "legacyRoles", ")", ")", ",", "}", "\n", "if", "n", ".", "prefix", "==", "\"", "\"", "{", "c", ".", "prefix", "=", "name", "\n", "}", "else", "{", "c", ".", "prefix", "=", "n", ".", "prefix", "+", "\"", "\"", "+", "name", "\n", "}", "\n", "n", ".", "children", "[", "name", "]", "=", "c", "\n", "return", "c", "\n", "}" ]

[ "child", "returns", "a", "direct", "child", "node", "creating", "it", "if", "necessary", "." ]

[ "func", "(", "n", "*", "metadataNode", ")", "attachACL", "(", "role", "string", ",", "e", "*", "packageACL", ")", "{", "n", ".", "assertNonFrozen", "(", ")", "\n\n", "// 'acls' are ordered by legacyRoles. Insert 'e' into the corresponding slot.", "// Such ordering is required by mergeIntoPrefixMetadata used by 'freeze'.", "for", "i", ",", "r", ":=", "range", "legacyRoles", "{", "if", "r", "==", "role", "{", "if", "n", ".", "acls", "[", "i", "]", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "role", ",", "n", ".", "prefix", ")", ")", "\n", "}", "\n", "n", ".", "acls", "[", "i", "]", "=", "e", "\n", "return", "\n", "}", "\n", "}", "\n\n", "// 'attachACL' is called only with roles validated by packageACL.parseKey(),", "// so this is impossible.", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "role", ")", ")", "\n", "}" ]

[ "attachACL", "attaches", "a", "packageACL", "to", "this", "node", ".", "All", "such", "attached", "ACLs", "are", "merged", "into", "single", "PrefixMetadata", "in", "freeze", "." ]

[ "func", "(", "n", "*", "metadataNode", ")", "freeze", "(", "c", "context", ".", "Context", ")", "{", "n", ".", "assertNonFrozen", "(", ")", "\n\n", "// md may be already non-nil for the root, this is fine.", "if", "n", ".", "md", "==", "nil", "{", "n", ".", "md", "=", "mergeIntoPrefixMetadata", "(", "c", ",", "n", ".", "prefix", ",", "n", ".", "acls", ")", "\n", "}", "\n", "n", ".", "acls", "=", "nil", "// mark as frozen, release unnecessary memory", "\n\n", "for", "_", ",", "child", ":=", "range", "n", ".", "children", "{", "child", ".", "freeze", "(", "c", ")", "\n", "}", "\n", "}" ]

[ "freeze", "marks", "the", "node", "and", "its", "subtree", "as", "fully", "constructed", "calculating", "their", "PrefixMetadata", "from", "attached", "ACLs", ".", "The", "context", "is", "used", "only", "for", "logging", "." ]

[ "func", "(", "n", "*", "metadataNode", ")", "metadata", "(", ")", "(", "md", "[", "]", "*", "api", ".", "PrefixMetadata", ")", "{", "n", ".", "assertFrozen", "(", ")", "\n", "if", "n", ".", "parent", "!=", "nil", "{", "md", "=", "n", ".", "parent", ".", "metadata", "(", ")", "\n", "}", "else", "{", "md", "=", "make", "(", "[", "]", "*", "api", ".", "PrefixMetadata", ",", "0", ",", "32", ")", "// 32 is picked arbitrarily", "\n", "}", "\n", "if", "n", ".", "md", "!=", "nil", "{", "md", "=", "append", "(", "md", ",", "n", ".", "md", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "metadata", "returns", "this", "node", "s", "and", "all", "inherited", "metadata", ".", "Root", "metadata", "first", ".", "The", "return", "value", "is", "never", "nil", ".", "If", "there", "s", "no", "metadata", "returns", "non", "-", "nil", "empty", "slice", "." ]

[ "func", "(", "g", "*", "metadataGraph", ")", "init", "(", "root", "*", "api", ".", "PrefixMetadata", ")", "{", "if", "root", "!=", "nil", "&&", "root", ".", "Prefix", "!=", "\"", "\"", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "g", ".", "root", "=", "&", "metadataNode", "{", "acls", ":", "make", "(", "[", "]", "*", "packageACL", ",", "len", "(", "legacyRoles", ")", ")", ",", "md", ":", "root", ",", "}", "\n", "}" ]

[ "init", "initializes", "the", "root", "node", "." ]

[ "func", "(", "g", "*", "metadataGraph", ")", "freeze", "(", "c", "context", ".", "Context", ")", "{", "g", ".", "root", ".", "freeze", "(", "c", ")", "\n", "}" ]

[ "freeze", "finalizes", "graph", "construction", "by", "calculating", "all", "PrefixMetadata", "items", ".", "The", "graph", "is", "not", "modifiable", "after", "this", "point", "but", "it", "becomes", "traversable", ".", "The", "context", "is", "used", "only", "for", "logging", "." ]

[ "func", "(", "yn", "*", "YesOrNo", ")", "Set", "(", "v", "string", ")", "error", "{", "switch", "v", "{", "case", "\"", "\"", ":", "*", "yn", "=", "true", "\n", "case", "\"", "\"", ":", "*", "yn", "=", "false", "\n", "default", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Set", "changes", "the", "value", "of", "YesOrNo", "." ]

[ "func", "YesOrNoField", "(", "f", "Field", ")", "Field", "{", "f", ".", "Type", "=", "FieldChoice", "\n", "f", ".", "ChoiceVariants", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n", "f", ".", "Validator", "=", "func", "(", "v", "string", ")", "error", "{", "var", "x", "YesOrNo", "\n", "return", "x", ".", "Set", "(", "v", ")", "\n", "}", "\n", "return", "f", "\n", "}" ]

[ "YesOrNoField", "modifies", "the", "field", "so", "that", "it", "corresponds", "to", "YesOrNo", "value", ".", "It", "sets", "Type", "ChoiceVariants", "and", "Validator", "properties", "." ]

[ "func", "(", "p", "*", "Properties", ")", "Validate", "(", ")", "error", "{", "if", "err", ":=", "p", ".", "LogStreamDescriptor", ".", "Validate", "(", "false", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "that", "the", "configured", "Properties", "are", "valid", "and", "sufficient", "to", "create", "a", "Butler", "stream", ".", "It", "skips", "stream", "Prefix", "validation", "and", "instead", "asserts", "that", "it", "is", "empty", "as", "it", "should", "not", "be", "populated", "when", "Properties", "are", "defined", "." ]

[ "func", "(", "p", "*", "Properties", ")", "Clone", "(", ")", "*", "Properties", "{", "clone", ":=", "*", "p", "\n", "clone", ".", "LogStreamDescriptor", "=", "proto", ".", "Clone", "(", "p", ".", "LogStreamDescriptor", ")", ".", "(", "*", "logpb", ".", "LogStreamDescriptor", ")", "\n", "return", "&", "clone", "\n", "}" ]

[ "Clone", "returns", "a", "fully", "-", "independent", "clone", "of", "this", "Properties", "object", "." ]

[ "func", "(", "f", "*", "Flags", ")", "Properties", "(", ")", "*", "Properties", "{", "contentType", ":=", "types", ".", "ContentType", "(", "f", ".", "ContentType", ")", "\n", "if", "contentType", "==", "\"", "\"", "{", "contentType", "=", "f", ".", "Type", ".", "DefaultContentType", "(", ")", "\n", "}", "\n\n", "p", ":=", "&", "Properties", "{", "LogStreamDescriptor", ":", "&", "logpb", ".", "LogStreamDescriptor", "{", "Name", ":", "string", "(", "f", ".", "Name", ")", ",", "ContentType", ":", "string", "(", "contentType", ")", ",", "StreamType", ":", "logpb", ".", "StreamType", "(", "f", ".", "Type", ")", ",", "Timestamp", ":", "google", ".", "NewTimestamp", "(", "time", ".", "Time", "(", "f", ".", "Timestamp", ")", ")", ",", "BinaryFileExt", ":", "f", ".", "BinaryFileExtension", ",", "Tags", ":", "f", ".", "Tags", ",", "}", ",", "Tee", ":", "f", ".", "Tee", ",", "Timeout", ":", "time", ".", "Duration", "(", "f", ".", "Timeout", ")", ",", "Deadline", ":", "time", ".", "Duration", "(", "f", ".", "Deadline", ")", ",", "}", "\n", "return", "p", "\n", "}" ]

[ "Properties", "converts", "the", "Flags", "to", "a", "standard", "Properties", "structure", ".", "If", "the", "values", "are", "not", "valid", "this", "conversion", "will", "return", "an", "error", "." ]

[ "func", "(", "b", "*", "bundle", ")", "GenerateEmail", "(", "templateName", "string", ",", "input", "*", "EmailTemplateInput", ")", "(", "subject", ",", "body", "string", ")", "{", "var", "err", "error", "\n", "if", "subject", ",", "body", ",", "err", "=", "b", ".", "executeUserTemplate", "(", "templateName", ",", "input", ")", ";", "err", "!=", "nil", "{", "// Execution of the user-defined template failed.", "// Fallback to the error template.", "subject", ",", "body", "=", "b", ".", "executeErrorTemplate", "(", "templateName", ",", "input", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "GenerateEmail", "generates", "an", "email", "using", "the", "named", "template", ".", "If", "the", "template", "fails", "an", "error", "template", "is", "used", "which", "includes", "error", "details", "and", "a", "link", "to", "the", "definition", "of", "the", "failed", "template", "." ]

[ "func", "(", "b", "*", "bundle", ")", "executeUserTemplate", "(", "templateName", "string", ",", "input", "*", "EmailTemplateInput", ")", "(", "subject", ",", "body", "string", ",", "err", "error", ")", "{", "if", "b", ".", "err", "!=", "nil", "{", "err", "=", "b", ".", "err", "\n", "return", "\n", "}", "\n\n", "var", "buf", "bytes", ".", "Buffer", "\n", "if", "err", "=", "b", ".", "subjects", ".", "ExecuteTemplate", "(", "&", "buf", ",", "templateName", ",", "input", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "subject", "=", "buf", ".", "String", "(", ")", "\n\n", "buf", ".", "Reset", "(", ")", "\n", "if", "err", "=", "b", ".", "bodies", ".", "ExecuteTemplate", "(", "&", "buf", ",", "templateName", ",", "input", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "body", "=", "buf", ".", "String", "(", ")", "\n", "return", "\n", "}" ]

[ "executeUserTemplate", "executed", "a", "user", "-", "defined", "template", ".", "If", "b", ".", "err", "is", "not", "nil", "returns", "it", "right", "away", "." ]

[ "func", "(", "b", "*", "bundle", ")", "executeErrorTemplate", "(", "templateName", "string", ",", "input", "*", "EmailTemplateInput", ",", "err", "error", ")", "(", "subject", ",", "body", "string", ")", "{", "subject", "=", "fmt", ".", "Sprintf", "(", "`[Build Status] Builder %q`", ",", "protoutil", ".", "FormatBuilderID", "(", "input", ".", "Build", ".", "Builder", ")", ")", "\n\n", "errorTemplateInput", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "input", ".", "Build", ",", "\"", "\"", ":", "templateName", ",", "\"", "\"", ":", "b", ".", "defURLs", "[", "templateName", "]", ",", "\"", "\"", ":", "err", ".", "Error", "(", ")", ",", "}", "\n", "var", "buf", "bytes", ".", "Buffer", "\n", "if", "err", ":=", "errorBodyTemplate", ".", "Execute", "(", "&", "buf", ",", "errorTemplateInput", ")", ";", "err", "!=", "nil", "{", "// Error template MAY NOT fail.", "panic", "(", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", ")", "\n", "}", "\n", "body", "=", "buf", ".", "String", "(", ")", "\n", "return", "\n", "}" ]

[ "executeErrorTemplate", "generates", "a", "spartan", "email", "that", "contains", "information", "about", "an", "error", "during", "execution", "of", "a", "user", "-", "defined", "template", "." ]

[ "func", "getBundle", "(", "c", "context", ".", "Context", ",", "projectId", "string", ")", "(", "*", "bundle", ",", "error", ")", "{", "// Untie c from the current transaction.", "// What we do here has nothing to do with a possible current transaction in c.", "c", "=", "datastore", ".", "WithoutTransaction", "(", "c", ")", "\n\n", "// Fetch current revision of the project config.", "project", ":=", "&", "config", ".", "Project", "{", "Name", ":", "projectId", "}", "\n", "if", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "project", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Lookup an exising bundle in the process cache.", "// If not available, make one and cache it.", "var", "transientErr", "error", "\n", "value", ",", "ok", ":=", "bundleCache", ".", "LRU", "(", "c", ")", ".", "Mutate", "(", "c", ",", "projectId", ",", "func", "(", "it", "*", "lru", ".", "Item", ")", "*", "lru", ".", "Item", "{", "if", "it", "!=", "nil", "&&", "it", ".", "Value", ".", "(", "*", "bundle", ")", ".", "revision", "==", "project", ".", "Revision", "{", "return", "it", "// Cache hit.", "\n", "}", "\n\n", "// Cache miss. Either no cached value or revision mismatch.", "// Fetch all templates from the Datastore transactionally with the project.", "// On a transient error, return it and do not purge cache.", "var", "templates", "[", "]", "*", "config", ".", "EmailTemplate", "\n", "transientErr", "=", "datastore", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "templates", "=", "templates", "[", ":", "0", "]", "// txn may be retried", "\n", "if", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "project", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "q", ":=", "datastore", ".", "NewQuery", "(", "\"", "\"", ")", ".", "Ancestor", "(", "datastore", ".", "KeyForObj", "(", "c", ",", "project", ")", ")", "\n", "return", "datastore", ".", "GetAll", "(", "c", ",", "q", ",", "&", "templates", ")", "\n", "}", ",", "nil", ")", "\n", "if", "transientErr", "!=", "nil", "{", "return", "it", "\n", "}", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "len", "(", "templates", ")", ",", "projectId", ")", "\n", "// Legacy: add a default template if we don't have one.", "// TODO(nodir): delete this once all projects define their templates.", "hasDefault", ":=", "false", "\n", "for", "_", ",", "t", ":=", "range", "templates", "{", "if", "t", ".", "Name", "==", "defaultTemplate", ".", "Name", "{", "hasDefault", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "hasDefault", "{", "templates", "=", "append", "(", "templates", ",", "&", "defaultTemplate", ")", "\n", "}", "\n\n", "// Bundle all fetched templates. If bundling/parsing fails, cache the error,", "// so we don't recompile bad templates over and over.", "b", ":=", "&", "bundle", "{", "revision", ":", "project", ".", "Revision", ",", "defURLs", ":", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "templates", ")", ")", ",", "subjects", ":", "text", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "config", ".", "EmailTemplateFuncs", ")", ",", "bodies", ":", "html", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "config", ".", "EmailTemplateFuncs", ")", ",", "}", "\n", "for", "_", ",", "t", ":=", "range", "templates", "{", "b", ".", "defURLs", "[", "t", ".", "Name", "]", "=", "t", ".", "DefinitionURL", "\n\n", "// Parse templates.", "// Do not stop the loop on failure because we want all defURLs.", "if", "b", ".", "err", "==", "nil", "{", "if", "_", ",", "b", ".", "err", "=", "b", ".", "subjects", ".", "New", "(", "t", ".", "Name", ")", ".", "Parse", "(", "t", ".", "SubjectTextTemplate", ")", ";", "b", ".", "err", "==", "nil", "{", "_", ",", "b", ".", "err", "=", "b", ".", "bodies", ".", "New", "(", "t", ".", "Name", ")", ".", "Parse", "(", "t", ".", "BodyHTMLTemplate", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Cache without expiration.", "return", "&", "lru", ".", "Item", "{", "Value", ":", "b", "}", "\n", "}", ")", "\n\n", "switch", "{", "case", "transientErr", "!=", "nil", ":", "return", "nil", ",", "transientErr", "\n", "case", "!", "ok", ":", "panic", "(", "\"", "\"", ")", "\n", "default", ":", "return", "value", ".", "(", "*", "bundle", ")", ",", "nil", "\n", "}", "\n", "}" ]

[ "getBundle", "returns", "a", "bundle", "of", "all", "email", "templates", "for", "the", "given", "project", ".", "The", "returned", "bundle", "is", "cached", "in", "the", "process", "memory", "do", "not", "modify", "it", ".", "Returns", "an", "error", "only", "on", "transient", "failures", ".", "Ignores", "an", "existing", "Datastore", "transaction", "in", "c", "if", "any", "." ]

[ "func", "(", "m", "*", "Machine", ")", "Enable", "(", ")", "{", "if", "!", "m", ".", "State", ".", "Enabled", "{", "m", ".", "State", "=", "State", "{", "Enabled", ":", "true", ",", "Generation", ":", "m", ".", "nextGen", "(", ")", ",", "LastRewind", ":", "m", ".", "Now", ",", "}", "\n", "m", ".", "scheduleTick", "(", "m", ".", "Now", ")", "\n", "}", "\n", "}" ]

[ "Enable", "makes", "the", "cron", "machine", "start", "counting", "time", ".", "Does", "nothing", "if", "already", "enabled", "." ]

[ "func", "(", "m", "*", "Machine", ")", "Disable", "(", ")", "{", "m", ".", "State", "=", "State", "{", "Enabled", ":", "false", ",", "Generation", ":", "m", ".", "nextGen", "(", ")", "}", "\n", "}" ]

[ "Disable", "stops", "any", "pending", "timer", "ticks", "resets", "state", ".", "The", "cron", "machine", "will", "ignore", "any", "events", "until", "Enable", "is", "called", "to", "turn", "it", "on", "." ]

[ "func", "(", "m", "*", "Machine", ")", "OnScheduleChange", "(", ")", "{", "// Do not touch timers on disabled cron machines.", "if", "!", "m", ".", "State", ".", "Enabled", "{", "return", "\n", "}", "\n\n", "// The following condition is true for cron machines on a relative schedule", "// that have already \"fired\", and currently wait for manual RewindIfNecessary", "// call to start ticking again. When such cron machines switch to an absolute", "// schedule, we need to rewind them right away (since machines on absolute", "// schedules always tick!). If the new schedule is also relative, do nothing:", "// RewindIfNecessary() should be called manually by the host at some later", "// time (as usual for relative schedules).", "if", "m", ".", "State", ".", "LastTick", ".", "When", ".", "IsZero", "(", ")", "{", "if", "m", ".", "Schedule", ".", "IsAbsolute", "(", ")", "{", "m", ".", "RewindIfNecessary", "(", ")", "\n", "}", "\n", "}", "else", "{", "// In this branch, the cron machine has a timer tick scheduled. It means it", "// is either in a relative or absolute schedule, and this schedule may have", "// changed, so we may need to move the tick to reflect the change. Note that", "// we are not resetting LastRewind here, since we want the new schedule to", "// take into account real last RewindIfNecessary call. For example, if the", "// last rewind happened at moment X, current time is Now, and the new", "// schedule is \"with 10s interval\", we want the tick to happen at \"X+10\",", "// not \"Now+10\".", "m", ".", "scheduleTick", "(", "m", ".", "Now", ")", "\n", "}", "\n", "}" ]

[ "OnScheduleChange", "happens", "when", "cron", "s", "schedule", "changes", ".", "In", "particular", "it", "handles", "switches", "between", "absolute", "and", "relative", "schedules", "." ]

[ "func", "(", "m", "*", "Machine", ")", "scheduleTick", "(", "now", "time", ".", "Time", ")", "{", "nextTickTime", ":=", "m", ".", "Schedule", ".", "Next", "(", "now", ",", "m", ".", "State", ".", "LastRewind", ")", "\n", "if", "nextTickTime", "!=", "m", ".", "State", ".", "LastTick", ".", "When", "{", "m", ".", "State", ".", "Generation", "=", "m", ".", "nextGen", "(", ")", "\n", "m", ".", "State", ".", "LastTick", "=", "TickLaterAction", "{", "When", ":", "nextTickTime", ",", "TickNonce", ":", "m", ".", "Nonce", "(", ")", ",", "}", "\n", "if", "nextTickTime", "!=", "schedule", ".", "DistantFuture", "{", "m", ".", "Actions", "=", "append", "(", "m", ".", "Actions", ",", "m", ".", "State", ".", "LastTick", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "scheduleTick", "emits", "TickLaterAction", "action", "according", "to", "the", "schedule", "current", "time", "and", "last", "time", "RewindIfNecessary", "was", "called", ".", "Does", "nothing", "if", "such", "tick", "has", "already", "been", "scheduled", "." ]

[ "func", "(", "m", "*", "Machine", ")", "rewindIfNecessary", "(", "now", "time", ".", "Time", ")", "{", "if", "m", ".", "State", ".", "Enabled", "&&", "m", ".", "State", ".", "LastTick", ".", "When", ".", "IsZero", "(", ")", "{", "m", ".", "State", ".", "LastRewind", "=", "now", "\n", "m", ".", "State", ".", "Generation", "=", "m", ".", "nextGen", "(", ")", "\n", "m", ".", "scheduleTick", "(", "now", ")", "\n", "}", "\n", "}" ]

[ "rewindIfNecessary", "implements", "RewindIfNecessary", "accepting", "corrected", "now", ".", "This", "is", "important", "for", "OnTimerTick", ".", "Note", "that", "m", ".", "Now", "is", "part", "of", "inputs", "and", "must", "not", "be", "mutated", "." ]

[ "func", "buildRulesQuery", "(", "c", "context", ".", "Context", ",", "req", "*", "minter", ".", "MintDelegationTokenRequest", ",", "requestor", "identity", ".", "Identity", ")", "(", "*", "RulesQuery", ",", "error", ")", "{", "// Validate 'delegated_identity'.", "var", "err", "error", "\n", "var", "delegator", "identity", ".", "Identity", "\n", "if", "req", ".", "DelegatedIdentity", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "req", ".", "DelegatedIdentity", "==", "Requestor", "{", "delegator", "=", "requestor", "// the requestor is delegating its own identity", "\n", "}", "else", "{", "if", "delegator", ",", "err", "=", "identity", ".", "MakeIdentity", "(", "req", ".", "DelegatedIdentity", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// Validate 'audience', convert it into a set.", "if", "len", "(", "req", ".", "Audience", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "audienceSet", ",", "err", ":=", "identityset", ".", "FromStrings", "(", "req", ".", "Audience", ",", "skipRequestor", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "sliceHasString", "(", "req", ".", "Audience", ",", "Requestor", ")", "{", "audienceSet", ".", "AddIdentity", "(", "requestor", ")", "\n", "}", "\n\n", "// Split 'services' into two lists: URLs and everything else (which is", "// \"service:...\" and \"*\" presumably, validated below).", "if", "len", "(", "req", ".", "Services", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "urls", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "req", ".", "Services", ")", ")", "\n", "rest", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "req", ".", "Services", ")", ")", "\n", "for", "_", ",", "srv", ":=", "range", "req", ".", "Services", "{", "if", "strings", ".", "HasPrefix", "(", "srv", ",", "\"", "\"", ")", "{", "urls", "=", "append", "(", "urls", ",", "srv", ")", "\n", "}", "else", "{", "rest", "=", "append", "(", "rest", ",", "srv", ")", "\n", "}", "\n", "}", "\n\n", "// Convert the list into a set, verify it contains only services (or \"*\").", "servicesSet", ",", "err", ":=", "identityset", ".", "FromStrings", "(", "rest", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "servicesSet", ".", "Groups", ")", "!=", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "ident", ":=", "range", "servicesSet", ".", "IDs", "{", "if", "ident", ".", "Kind", "(", ")", "!=", "identity", ".", "Service", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ident", ")", "\n", "}", "\n", "}", "\n\n", "// Resolve URLs into app IDs. This may involve URL fetch calls (if the cache", "// is cold), so skip this expensive call if already specifying the universal", "// set of all services.", "if", "!", "servicesSet", ".", "All", "&&", "len", "(", "urls", ")", "!=", "0", "{", "if", "err", "=", "resolveServiceIDs", "(", "c", ",", "urls", ",", "servicesSet", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// Done!", "return", "&", "RulesQuery", "{", "Requestor", ":", "requestor", ",", "Delegator", ":", "delegator", ",", "Audience", ":", "audienceSet", ",", "Services", ":", "servicesSet", ",", "}", ",", "nil", "\n", "}" ]

[ "buildRulesQuery", "validates", "the", "request", "extracts", "and", "normalizes", "relevant", "fields", "into", "RulesQuery", "object", ".", "May", "return", "transient", "errors", "." ]

[ "func", "RunShared", "(", "ctx", "context", ".", "Context", ",", "env", "subcommands", ".", "Env", ",", "command", "[", "]", "string", ")", "error", "{", "ctx", ",", "cancel", ":=", "clock", ".", "WithTimeout", "(", "ctx", ",", "lib", ".", "DefaultCommandTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "return", "lib", ".", "RunShared", "(", "ctx", ",", "env", ",", "func", "(", "ctx", "context", ".", "Context", ")", "error", "{", "return", "runCommand", "(", "ctx", ",", "command", ")", "\n", "}", ")", "\n", "}" ]

[ "RunShared", "runs", "the", "command", "with", "the", "specified", "environment", "while", "holding", "a", "shared", "mmutex", "lock", "." ]

[ "func", "(", "pl", "*", "PackageLoader", ")", "Resolve", "(", "c", "context", ".", "Context", ",", "e", "*", "vpython", ".", "Environment", ")", "error", "{", "spec", ":=", "e", ".", "Spec", "\n", "if", "spec", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "expander", ",", "err", ":=", "pl", ".", "expanderForTags", "(", "c", ",", "e", ".", "Pep425Tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Generate CIPD client options. If no root is provided, use a temporary root.", "if", "pl", ".", "Options", ".", "Root", "!=", "\"", "\"", "{", "return", "pl", ".", "resolveWithOpts", "(", "c", ",", "pl", ".", "Options", ",", "expander", ",", "spec", ")", "\n", "}", "\n\n", "td", ":=", "filesystem", ".", "TempDir", "{", "Prefix", ":", "\"", "\"", ",", "CleanupErrFunc", ":", "func", "(", "tdir", "string", ",", "err", "error", ")", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "tdir", ")", "\n", "}", ",", "}", "\n", "return", "td", ".", "With", "(", "func", "(", "tdir", "string", ")", "error", "{", "opts", ":=", "pl", ".", "Options", "\n", "opts", ".", "Root", "=", "tdir", "\n\n", "return", "pl", ".", "resolveWithOpts", "(", "c", ",", "opts", ",", "expander", ",", "spec", ")", "\n", "}", ")", "\n", "}" ]

[ "Resolve", "implements", "venv", ".", "PackageLoader", ".", "The", "resulting", "packages", "slice", "will", "be", "updated", "in", "-", "place", "with", "the", "resolved", "package", "name", "and", "instance", "ID", "." ]

[ "func", "(", "pl", "*", "PackageLoader", ")", "resolveWithOpts", "(", "c", "context", ".", "Context", ",", "opts", "cipd", ".", "ClientOptions", ",", "expander", "template", ".", "Expander", ",", "spec", "*", "vpython", ".", "Spec", ")", "error", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "opts", ".", "Root", ")", "\n", "ef", ",", "packages", ":=", "specToEnsureFile", "(", "spec", ")", "\n\n", "// Log our unresolved packages. Note that \"specToEnsureFile\" only creates", "// a subdir entry for the root (\"\"), so we don't need to deterministically", "// iterate over the full map.", "if", "logging", ".", "IsLogging", "(", "c", ",", "logging", ".", "Debug", ")", "{", "for", "_", ",", "pkg", ":=", "range", "ef", ".", "PackagesBySubdir", "[", "\"", "\"", "]", "{", "logging", ".", "Debugf", "(", "c", ",", "\"", "\\t", "\"", ",", "pkg", ")", "\n", "}", "\n", "}", "\n\n", "client", ",", "err", ":=", "cipd", ".", "NewClient", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Start a CIPD client batch.", "client", ".", "BeginBatch", "(", "c", ")", "\n", "defer", "client", ".", "EndBatch", "(", "c", ")", "\n\n", "// Resolve our ensure file.", "resolver", ":=", "cipd", ".", "Resolver", "{", "Client", ":", "client", "}", "\n", "resolved", ",", "err", ":=", "resolver", ".", "Resolve", "(", "c", ",", "ef", ",", "expander", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Write the results to \"packages\". All of them should have been installed", "// into the root subdir.", "for", "i", ",", "pkg", ":=", "range", "resolved", ".", "PackagesBySubdir", "[", "\"", "\"", "]", "{", "packages", "[", "i", "]", ".", "Name", "=", "pkg", ".", "PackageName", "\n", "packages", "[", "i", "]", ".", "Version", "=", "pkg", ".", "InstanceID", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "resolveWithOpts", "resolves", "the", "specified", "packages", ".", "The", "supplied", "spec", "is", "updated", "with", "the", "resolved", "packages", "." ]

[ "func", "(", "pl", "*", "PackageLoader", ")", "Verify", "(", "c", "context", ".", "Context", ",", "sp", "*", "vpython", ".", "Spec", ",", "tags", "[", "]", "*", "vpython", ".", "PEP425Tag", ")", "error", "{", "client", ",", "err", ":=", "cipd", ".", "NewClient", "(", "pl", ".", "Options", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "client", ".", "BeginBatch", "(", "c", ")", "\n", "defer", "client", ".", "EndBatch", "(", "c", ")", "\n\n", "resolver", ":=", "cipd", ".", "Resolver", "{", "Client", ":", "client", ",", "VerifyPresence", ":", "true", ",", "}", "\n\n", "// Build an Ensure file for our specification under each tag and register it", "// with our Resolver.", "ensureFileErrors", ":=", "0", "\n", "for", "_", ",", "tag", ":=", "range", "tags", "{", "tagSlice", ":=", "[", "]", "*", "vpython", ".", "PEP425Tag", "{", "tag", "}", "\n\n", "tagSpec", ":=", "sp", ".", "Clone", "(", ")", "\n", "if", "err", ":=", "spec", ".", "NormalizeSpec", "(", "tagSpec", ",", "tagSlice", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "tag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Convert our spec into an ensure file.", "ef", ",", "_", ":=", "specToEnsureFile", "(", "tagSpec", ")", "\n\n", "expander", ",", "err", ":=", "pl", ".", "expanderForTags", "(", "c", ",", "tagSlice", ")", "\n", "if", "err", "!=", "nil", "{", "ensureFileErrors", "++", "\n", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "tag", ".", "TagString", "(", ")", ")", "\n", "continue", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "resolver", ".", "Resolve", "(", "c", ",", "ef", ",", "expander", ")", ";", "err", "!=", "nil", "{", "ensureFileErrors", "++", "\n", "ts", ":=", "tag", ".", "TagString", "(", ")", "\n", "if", "merr", ",", "ok", ":=", "err", ".", "(", "errors", ".", "MultiError", ")", ";", "ok", "{", "for", "_", ",", "err", ":=", "range", "merr", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "ts", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "ts", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "ensureFileErrors", ">", "0", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "ensureFileErrors", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "Verify", "implements", "venv", ".", "PackageLoader", "." ]

[ "func", "RegisterCallbackIn", "(", "ctx", "context", ".", "Context", ",", "f", "Callback", ")", "{", "GetState", "(", "ctx", ")", ".", "RegisterCallbacks", "(", "f", ")", "\n", "}" ]

[ "RegisterCallbackIn", "is", "like", "RegisterCallback", "but", "registers", "in", "a", "given", "context", "." ]

[ "func", "RegisterGlobalCallbackIn", "(", "ctx", "context", ".", "Context", ",", "f", "Callback", ",", "metrics", "...", "types", ".", "Metric", ")", "{", "if", "len", "(", "metrics", ")", "==", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "GetState", "(", "ctx", ")", ".", "RegisterGlobalCallbacks", "(", "GlobalCallback", "{", "f", ",", "metrics", "}", ")", "\n", "}" ]

[ "RegisterGlobalCallbackIn", "is", "like", "RegisterGlobalCallback", "but", "registers", "in", "a", "given", "context", "." ]

[ "func", "DecodeString", "(", "s", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "src", ":=", "[", "]", "byte", "(", "s", ")", "\n", "dst", ":=", "make", "(", "[", "]", "byte", ",", "DecodedLen", "(", "len", "(", "src", ")", ")", ")", "\n", "if", "_", ",", "err", ":=", "Decode", "(", "dst", ",", "src", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "dst", ",", "nil", "\n", "}" ]

[ "DecodeString", "returns", "the", "bytes", "represented", "by", "the", "base128", "string", "s", "." ]

[ "func", "TextStreamFlags", "(", "ctx", "context", ".", "Context", ",", "name", "types", ".", "StreamName", ")", "streamproto", ".", "Flags", "{", "return", "streamFlagsFromArchetype", "(", "ctx", ",", "name", ",", "&", "textStreamArchetype", ")", "\n", "}" ]

[ "TextStreamFlags", "returns", "the", "streamproto", ".", "Flags", "for", "a", "text", "stream", "using", "Annotee", "s", "text", "stream", "archetype", "." ]

[ "func", "ValidateHostname", "(", "hostname", "string", ")", "error", "{", "if", "len", "(", "hostname", ")", ">", "255", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "hostnameRegexp", ".", "MatchString", "(", "hostname", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "hostnameRegexp", ")", "\n", "}", "\n", "for", "_", ",", "s", ":=", "range", "strings", ".", "Split", "(", "hostname", ",", "\"", "\"", ")", "{", "if", "len", "(", "s", ")", ">", "63", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateHostname", "returns", "an", "error", "if", "the", "given", "string", "is", "not", "a", "valid", "RFC1123", "hostname", "." ]

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

[ "printOSes", "prints", "operating", "system", "data", "to", "stdout", "in", "tab", "-", "separated", "columns", "." ]

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

[ "Run", "runs", "the", "command", "to", "get", "operating", "systems", "." ]

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

[ "getOSesCmd", "returns", "a", "command", "to", "get", "operating", "systems", "." ]

[ "func", "tagMapFromProperties", "(", "props", "ds", ".", "PropertySlice", ")", "(", "TagMap", ",", "error", ")", "{", "tm", ":=", "TagMap", "{", "}", "\n", "lme", ":=", "errors", ".", "NewLazyMultiError", "(", "len", "(", "props", ")", ")", "\n", "for", "idx", ",", "prop", ":=", "range", "props", "{", "v", ",", "ok", ":=", "prop", ".", "Value", "(", ")", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "lme", ".", "Assign", "(", "idx", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "prop", ".", "Value", "(", ")", ")", ")", "\n", "continue", "\n", "}", "\n", "e", ",", "err", ":=", "decodeKey", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "lme", ".", "Assign", "(", "idx", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ",", "err", ")", ")", "\n", "continue", "\n", "}", "\n\n", "parts", ":=", "strings", ".", "SplitN", "(", "e", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "// This is a presence entry. Ignore.", "continue", "\n", "}", "\n", "k", ",", "v", ":=", "parts", "[", "0", "]", ",", "parts", "[", "1", "]", "\n\n", "if", "err", ":=", "types", ".", "ValidateTag", "(", "k", ",", "v", ")", ";", "err", "!=", "nil", "{", "lme", ".", "Assign", "(", "idx", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "parts", "[", "0", "]", ",", "err", ")", ")", "\n", "continue", "\n", "}", "\n", "tm", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "if", "len", "(", "tm", ")", "==", "0", "{", "tm", "=", "nil", "\n", "}", "\n", "return", "tm", ",", "lme", ".", "Get", "(", ")", "\n", "}" ]

[ "tagMapFromProperties", "converts", "a", "set", "of", "tag", "property", "objects", "into", "a", "TagMap", ".", "If", "an", "error", "occurs", "decoding", "a", "specific", "property", "an", "errors", ".", "MultiError", "will", "be", "returned", "alongside", "the", "successfully", "-", "decoded", "tags", "." ]

[ "func", "(", "m", "TagMap", ")", "toProperties", "(", ")", "(", "ds", ".", "PropertySlice", ",", "error", ")", "{", "if", "len", "(", "m", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Deterministic conversion.", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "m", ")", ")", "\n", "for", "k", ":=", "range", "m", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n\n", "parts", ":=", "make", "(", "ds", ".", "PropertySlice", ",", "0", ",", "len", "(", "m", ")", "*", "2", ")", "\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "v", ":=", "m", "[", "k", "]", "\n", "if", "err", ":=", "types", ".", "ValidateTag", "(", "k", ",", "v", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Presence entry.", "parts", "=", "append", "(", "parts", ",", "ds", ".", "MkProperty", "(", "encodeKey", "(", "k", ")", ")", ")", "\n\n", "// Value entry.", "parts", "=", "append", "(", "parts", ",", "ds", ".", "MkProperty", "(", "encodeKey", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ",", "v", ")", ")", ")", ")", "\n", "}", "\n", "return", "parts", ",", "nil", "\n", "}" ]

[ "toProperties", "converts", "a", "TagMap", "to", "a", "set", "of", "Property", "objects", "for", "storage", "." ]

[ "func", "AddLogStreamTagFilter", "(", "q", "*", "ds", ".", "Query", ",", "key", "string", ",", "value", "string", ")", "*", "ds", ".", "Query", "{", "if", "value", "==", "\"", "\"", "{", "return", "q", ".", "Eq", "(", "\"", "\"", ",", "encodeKey", "(", "key", ")", ")", "\n", "}", "\n", "return", "q", ".", "Eq", "(", "\"", "\"", ",", "encodeKey", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ",", "value", ")", ")", ")", "\n", "}" ]

[ "AddLogStreamTagFilter", "adds", "a", "tag", "filter", "to", "a", "Query", "object", ".", "This", "method", "will", "only", "add", "equality", "filters", "to", "the", "query", ".", "If", "value", "is", "empty", "a", "presence", "filter", "will", "be", "added", ";", "otherwise", "an", "equality", "filter", "will", "be", "added", ".", "This", "incorporates", "the", "encoding", "expressed", "by", "TagMap", "." ]

[ "func", "Register", "(", "rk", "string", ",", "f", "Formatter", ")", "{", "if", "rk", "==", "\"", "\"", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "registry", ".", "Lock", "(", ")", "\n", "defer", "registry", ".", "Unlock", "(", ")", "\n\n", "if", "_", ",", "ok", ":=", "registry", ".", "r", "[", "rk", "]", ";", "ok", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rk", ")", ")", "\n", "}", "\n", "if", "registry", ".", "r", "==", "nil", "{", "registry", ".", "r", "=", "map", "[", "string", "]", "Formatter", "{", "}", "\n", "}", "\n", "registry", ".", "r", "[", "rk", "]", "=", "f", "\n", "}" ]

[ "Register", "registers", "a", "Formatter", "implementation", "for", "given", "format", ".", "If", "the", "supplied", "key", "is", "already", "registered", "Register", "will", "panic", "." ]

[ "func", "getFormatter", "(", "f", "string", ")", "(", "Formatter", ",", "error", ")", "{", "registry", ".", "RLock", "(", ")", "\n", "defer", "registry", ".", "RUnlock", "(", ")", "\n\n", "formatter", ":=", "registry", ".", "r", "[", "f", "]", "\n", "if", "formatter", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ",", "f", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "formatter", ",", "nil", "\n", "}" ]

[ "getFormatter", "returns", "the", "Formatter", "associated", "with", "the", "provided", "Format", "." ]

[ "func", "EqualTokens", "(", "a", ",", "b", "*", "Token", ")", "bool", "{", "if", "a", "==", "b", "{", "return", "true", "\n", "}", "\n", "if", "a", "==", "nil", "{", "a", "=", "&", "Token", "{", "}", "\n", "}", "\n", "if", "b", "==", "nil", "{", "b", "=", "&", "Token", "{", "}", "\n", "}", "\n", "return", "a", ".", "AccessToken", "==", "b", ".", "AccessToken", "&&", "a", ".", "Expiry", ".", "Equal", "(", "b", ".", "Expiry", ")", "&&", "a", ".", "Email", "==", "b", ".", "Email", "\n", "}" ]

[ "EqualTokens", "returns", "true", "if", "tokens", "are", "equal", ".", "nil", "token", "corresponds", "to", "an", "empty", "access", "token", "." ]

[ "func", "isBadKeyError", "(", "err", "error", ")", "bool", "{", "if", "err", "==", "nil", "{", "return", "false", "\n", "}", "\n", "// See https://go.googlesource.com/oauth2.git/+/197281d4/internal/oauth2.go#32", "// Unfortunately, if uses fmt.Errorf.", "s", ":=", "err", ".", "Error", "(", ")", "\n", "return", "strings", ".", "Contains", "(", "s", ",", "\"", "\"", ")", "||", "s", "==", "\"", "\"", "\n", "}" ]

[ "isBadKeyError", "sniffs", "out", "errors", "related", "to", "malformed", "private", "keys", "." ]

[ "func", "GetSwarming", "(", "ctx", "context", ".", "Context", ")", "*", "Swarming", "{", "ret", ":=", "Swarming", "{", "}", "\n", "ok", ",", "err", ":=", "Lookup", "(", "ctx", ",", "\"", "\"", ",", "&", "ret", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "return", "&", "ret", "\n", "}" ]

[ "GetSwarming", "calls", "Lookup", "and", "returns", "the", "current", "Swarming", "from", "LUCI_CONTEXT", "if", "it", "was", "present", ".", "If", "no", "Swarming", "is", "in", "the", "context", "this", "returns", "nil", "." ]

[ "func", "SetSwarming", "(", "ctx", "context", ".", "Context", ",", "swarm", "*", "Swarming", ")", "context", ".", "Context", "{", "var", "raw", "interface", "{", "}", "\n", "if", "swarm", "!=", "nil", "{", "raw", "=", "swarm", "\n", "}", "\n", "ctx", ",", "err", ":=", "Set", "(", "ctx", ",", "\"", "\"", ",", "raw", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "return", "ctx", "\n", "}" ]

[ "SetSwarming", "Sets", "the", "Swarming", "in", "the", "LUCI_CONTEXT", "." ]

[ "func", "(", "k", "cursorKind", ")", "cursorKey", "(", "pkg", ",", "cursor", "string", ")", "string", "{", "blob", ":=", "sha256", ".", "Sum224", "(", "[", "]", "byte", "(", "pkg", "+", "\"", "\"", "+", "cursor", ")", ")", "\n", "return", "string", "(", "k", ")", "+", "\"", "\"", "+", "base64", ".", "RawStdEncoding", ".", "EncodeToString", "(", "blob", "[", ":", "]", ")", "\n", "}" ]

[ "cursorKey", "is", "a", "memcache", "key", "for", "items", "that", "link", "cursor", "to", "a", "previous", "page", "." ]