Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.3k

[ "func", "(", "r", "*", "relations", ")", "GetInfo", "(", ")", "map", "[", "int", "]", "*", "context", ".", "RelationInfo", "{", "relationInfos", ":=", "map", "[", "int", "]", "*", "context", ".", "RelationInfo", "{", "}", "\n", "for", "id", ",", "relationer", ":=", "range", "r", ".", "relationers", "{", "relationInfos", "[", "id", "]", "=", "relationer", ".", "ContextInfo", "(", ")", "\n", "}", "\n", "return", "relationInfos", "\n", "}" ]

[ "GetInfo", "is", "part", "of", "the", "Relations", "interface", "." ]

[ "func", "(", "r", "*", "relations", ")", "add", "(", "rel", "*", "uniter", ".", "Relation", ",", "dir", "*", "StateDir", ")", "(", "err", "error", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "rel", ")", "\n", "ru", ",", "err", ":=", "rel", ".", "Unit", "(", "r", ".", "unit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "relationer", ":=", "NewRelationer", "(", "ru", ",", "dir", ")", "\n", "unitWatcher", ",", "err", ":=", "r", ".", "unit", ".", "Watch", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "e", ":=", "worker", ".", "Stop", "(", "unitWatcher", ")", ";", "e", "!=", "nil", "{", "if", "err", "==", "nil", "{", "err", "=", "e", "\n", "}", "else", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "e", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "r", ".", "abort", ":", "// Should this be a different error? e.g. resolver.ErrAborted, that", "// Loop translates into ErrLoopAborted?", "return", "resolver", ".", "ErrLoopAborted", "\n", "case", "_", ",", "ok", ":=", "<-", "unitWatcher", ".", "Changes", "(", ")", ":", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "err", ":=", "relationer", ".", "Join", "(", ")", "\n", "if", "params", ".", "IsCodeCannotEnterScopeYet", "(", "err", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "rel", ")", "\n", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "rel", ")", "\n", "// Leaders get to set the relation status.", "var", "isLeader", "bool", "\n", "isLeader", ",", "err", "=", "r", ".", "leaderCtx", ".", "IsLeader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "isLeader", "{", "err", "=", "rel", ".", "SetStatus", "(", "relation", ".", "Joined", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "r", ".", "relationers", "[", "rel", ".", "Id", "(", ")", "]", "=", "relationer", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "add", "causes", "the", "unit", "agent", "to", "join", "the", "supplied", "relation", "and", "to", "store", "persistent", "state", "in", "the", "supplied", "dir", ".", "It", "will", "block", "until", "the", "operation", "succeeds", "or", "fails", ";", "or", "until", "the", "abort", "chan", "is", "closed", "in", "which", "case", "it", "will", "return", "resolver", ".", "ErrLoopAborted", "." ]

[ "func", "(", "r", "*", "relations", ")", "setDying", "(", "id", "int", ")", "error", "{", "relationer", ",", "found", ":=", "r", ".", "relationers", "[", "id", "]", "\n", "if", "!", "found", "{", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "relationer", ".", "SetDying", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "relationer", ".", "IsImplicit", "(", ")", "{", "delete", "(", "r", ".", "relationers", ",", "id", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setDying", "notifies", "the", "relationer", "identified", "by", "the", "supplied", "id", "that", "the", "only", "hook", "executions", "to", "be", "requested", "should", "be", "those", "necessary", "to", "cleanly", "exit", "the", "relation", "." ]

[ "func", "AuthAny", "(", "getFuncs", "...", "GetAuthFunc", ")", "GetAuthFunc", "{", "return", "func", "(", ")", "(", "AuthFunc", ",", "error", ")", "{", "funcs", ":=", "make", "(", "[", "]", "AuthFunc", ",", "len", "(", "getFuncs", ")", ")", "\n", "for", "i", ",", "getFunc", ":=", "range", "getFuncs", "{", "f", ",", "err", ":=", "getFunc", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "funcs", "[", "i", "]", "=", "f", "\n", "}", "\n", "combined", ":=", "func", "(", "tag", "names", ".", "Tag", ")", "bool", "{", "for", "_", ",", "f", ":=", "range", "funcs", "{", "if", "f", "(", "tag", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "return", "combined", ",", "nil", "\n", "}", "\n", "}" ]

[ "AuthAny", "returns", "an", "AuthFunc", "generator", "that", "returns", "an", "AuthFunc", "that", "accepts", "any", "tag", "authorized", "by", "any", "of", "its", "arguments", ".", "If", "no", "arguments", "are", "passed", "this", "is", "equivalent", "to", "AuthNever", "." ]

[ "func", "AuthAlways", "(", ")", "GetAuthFunc", "{", "return", "func", "(", ")", "(", "AuthFunc", ",", "error", ")", "{", "return", "func", "(", "tag", "names", ".", "Tag", ")", "bool", "{", "return", "true", "\n", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "AuthAlways", "returns", "an", "authentication", "function", "that", "always", "returns", "true", "iff", "it", "is", "passed", "a", "valid", "tag", "." ]

[ "func", "AuthFuncForTag", "(", "valid", "names", ".", "Tag", ")", "GetAuthFunc", "{", "return", "func", "(", ")", "(", "AuthFunc", ",", "error", ")", "{", "return", "func", "(", "tag", "names", ".", "Tag", ")", "bool", "{", "return", "tag", "==", "valid", "\n", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "AuthFuncForTag", "returns", "an", "authentication", "function", "that", "always", "returns", "true", "iff", "it", "is", "passed", "a", "specific", "tag", "." ]

[ "func", "AuthFuncForTagKind", "(", "kind", "string", ")", "GetAuthFunc", "{", "return", "func", "(", ")", "(", "AuthFunc", ",", "error", ")", "{", "if", "kind", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "func", "(", "tag", "names", ".", "Tag", ")", "bool", "{", "// Allow only the given tag kind.", "if", "tag", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "tag", ".", "Kind", "(", ")", "==", "kind", "\n", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "AuthFuncForTagKind", "returns", "a", "GetAuthFunc", "which", "creates", "an", "AuthFunc", "allowing", "only", "the", "given", "tag", "kind", "and", "denies", "all", "others", ".", "Passing", "an", "empty", "kind", "is", "an", "error", "." ]

[ "func", "AuthFuncForMachineAgent", "(", "authorizer", "Authorizer", ")", "GetAuthFunc", "{", "return", "func", "(", ")", "(", "AuthFunc", ",", "error", ")", "{", "isModelManager", ":=", "authorizer", ".", "AuthController", "(", ")", "\n", "isMachineAgent", ":=", "authorizer", ".", "AuthMachineAgent", "(", ")", "\n", "authEntityTag", ":=", "authorizer", ".", "GetAuthTag", "(", ")", "\n\n", "return", "func", "(", "tag", "names", ".", "Tag", ")", "bool", "{", "if", "isMachineAgent", "&&", "tag", "==", "authEntityTag", "{", "// A machine agent can always access its own machine.", "return", "true", "\n", "}", "\n\n", "switch", "tag", ":=", "tag", ".", "(", "type", ")", "{", "case", "names", ".", "MachineTag", ":", "parentId", ":=", "state", ".", "ParentId", "(", "tag", ".", "Id", "(", ")", ")", "\n", "if", "parentId", "==", "\"", "\"", "{", "// All top-level machines are accessible by the controller.", "return", "isModelManager", "\n", "}", "\n", "// All containers with the authenticated machine as a", "// parent are accessible by it.", "// TODO(dfc) sometimes authEntity tag is nil, which is fine because nil is", "// only equal to nil, but it suggests someone is passing an authorizer", "// with a nil tag.", "return", "isMachineAgent", "&&", "names", ".", "NewMachineTag", "(", "parentId", ")", "==", "authEntityTag", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "AuthFuncForMachineAgent", "returns", "a", "GetAuthFunc", "which", "creates", "an", "AuthFunc", "allowing", "only", "machine", "agents", "and", "their", "controllers" ]

[ "func", "convertConstraints", "(", "cons", "constraints", ".", "Value", ")", "url", ".", "Values", "{", "params", ":=", "url", ".", "Values", "{", "}", "\n", "if", "cons", ".", "Arch", "!=", "nil", "{", "// Note: Juju and MAAS use the same architecture names.", "// MAAS also accepts a subarchitecture (e.g. \"highbank\"", "// for ARM), which defaults to \"generic\" if unspecified.", "params", ".", "Add", "(", "\"", "\"", ",", "*", "cons", ".", "Arch", ")", "\n", "}", "\n", "if", "cons", ".", "CpuCores", "!=", "nil", "{", "params", ".", "Add", "(", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "*", "cons", ".", "CpuCores", ")", ")", "\n", "}", "\n", "if", "cons", ".", "Mem", "!=", "nil", "{", "params", ".", "Add", "(", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "*", "cons", ".", "Mem", ")", ")", "\n", "}", "\n", "convertTagsToParams", "(", "params", ",", "cons", ".", "Tags", ")", "\n", "if", "cons", ".", "CpuPower", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "params", "\n", "}" ]

[ "convertConstraints", "converts", "the", "given", "constraints", "into", "an", "url", ".", "Values", "object", "suitable", "to", "pass", "to", "MAAS", "when", "acquiring", "a", "node", ".", "CpuPower", "is", "ignored", "because", "it", "cannot", "be", "translated", "into", "something", "meaningful", "for", "MAAS", "right", "now", "." ]

[ "func", "convertConstraints2", "(", "cons", "constraints", ".", "Value", ")", "gomaasapi", ".", "AllocateMachineArgs", "{", "params", ":=", "gomaasapi", ".", "AllocateMachineArgs", "{", "}", "\n", "if", "cons", ".", "Arch", "!=", "nil", "{", "params", ".", "Architecture", "=", "*", "cons", ".", "Arch", "\n", "}", "\n", "if", "cons", ".", "CpuCores", "!=", "nil", "{", "params", ".", "MinCPUCount", "=", "int", "(", "*", "cons", ".", "CpuCores", ")", "\n", "}", "\n", "if", "cons", ".", "Mem", "!=", "nil", "{", "params", ".", "MinMemory", "=", "int", "(", "*", "cons", ".", "Mem", ")", "\n", "}", "\n", "if", "cons", ".", "Tags", "!=", "nil", "{", "positives", ",", "negatives", ":=", "parseDelimitedValues", "(", "*", "cons", ".", "Tags", ")", "\n", "if", "len", "(", "positives", ")", ">", "0", "{", "params", ".", "Tags", "=", "positives", "\n", "}", "\n", "if", "len", "(", "negatives", ")", ">", "0", "{", "params", ".", "NotTags", "=", "negatives", "\n", "}", "\n", "}", "\n", "if", "cons", ".", "CpuPower", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "params", "\n", "}" ]

[ "convertConstraints2", "converts", "the", "given", "constraints", "into", "a", "gomaasapi", ".", "AllocateMachineArgs", "for", "paasing", "to", "MAAS", "2", "." ]

[ "func", "convertSpacesFromConstraints", "(", "spaces", "*", "[", "]", "string", ")", "(", "[", "]", "string", ",", "[", "]", "string", ")", "{", "if", "spaces", "==", "nil", "||", "len", "(", "*", "spaces", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "parseDelimitedValues", "(", "*", "spaces", ")", "\n", "}" ]

[ "convertSpacesFromConstraints", "extracts", "spaces", "from", "constraints", "and", "converts", "them", "to", "two", "lists", "of", "positive", "and", "negative", "spaces", "." ]

[ "func", "addStorage", "(", "params", "url", ".", "Values", ",", "volumes", "[", "]", "volumeInfo", ")", "{", "if", "len", "(", "volumes", ")", "==", "0", "{", "return", "\n", "}", "\n", "// Requests for specific values are passed to the acquire URL", "// as a storage URL parameter of the form:", "// [volume-name:]sizeinGB[tag,...]", "// See http://maas.ubuntu.com/docs/api.html#nodes", "// eg storage=root:0(ssd),data:20(magnetic,5400rpm),45", "makeVolumeParams", ":=", "func", "(", "v", "volumeInfo", ")", "string", "{", "var", "params", "string", "\n", "if", "v", ".", "name", "!=", "\"", "\"", "{", "params", "=", "v", ".", "name", "+", "\"", "\"", "\n", "}", "\n", "params", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ".", "sizeInGB", ")", "\n", "if", "len", "(", "v", ".", "tags", ")", ">", "0", "{", "params", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "v", ".", "tags", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "return", "params", "\n", "}", "\n", "var", "volParms", "[", "]", "string", "\n", "for", "_", ",", "v", ":=", "range", "volumes", "{", "params", ":=", "makeVolumeParams", "(", "v", ")", "\n", "volParms", "=", "append", "(", "volParms", ",", "params", ")", "\n", "}", "\n", "params", ".", "Add", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "volParms", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "addStorage", "converts", "volume", "information", "into", "url", ".", "Values", "object", "suitable", "to", "pass", "to", "MAAS", "when", "acquiring", "a", "node", "." ]

[ "func", "addStorage2", "(", "params", "*", "gomaasapi", ".", "AllocateMachineArgs", ",", "volumes", "[", "]", "volumeInfo", ")", "{", "if", "len", "(", "volumes", ")", "==", "0", "{", "return", "\n", "}", "\n", "var", "volParams", "[", "]", "gomaasapi", ".", "StorageSpec", "\n", "for", "_", ",", "v", ":=", "range", "volumes", "{", "volSpec", ":=", "gomaasapi", ".", "StorageSpec", "{", "Label", ":", "v", ".", "name", ",", "Size", ":", "int", "(", "v", ".", "sizeInGB", ")", ",", "Tags", ":", "v", ".", "tags", ",", "}", "\n", "volParams", "=", "append", "(", "volParams", ",", "volSpec", ")", "\n", "}", "\n", "params", ".", "Storage", "=", "volParams", "\n", "}" ]

[ "addStorage2", "adds", "volume", "information", "onto", "a", "gomaasapi", ".", "AllocateMachineArgs", "object", "suitable", "to", "pass", "to", "MAAS", "2", "when", "acquiring", "a", "node", "." ]

[ "func", "resourceTagsToDiskLabels", "(", "in", "map", "[", "string", "]", "string", ")", "map", "[", "string", "]", "string", "{", "out", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "k", ",", "v", ":=", "range", "in", "{", "// Only the controller and model UUID tags are carried", "// over, as they're known not to conflict with GCE's", "// rules regarding label values.", "switch", "k", "{", "case", "tags", ".", "JujuController", ",", "tags", ".", "JujuModel", ":", "out", "[", "k", "]", "=", "v", "\n", "}", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "resourceTagsToDiskLabels", "translates", "a", "set", "of", "resource", "tags", "provided", "by", "Juju", "to", "disk", "labels", "." ]

[ "func", "(", "config", "FlagManifoldConfig", ")", "start", "(", "context", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "var", "gate", "Waiter", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "GateName", ",", "&", "gate", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "worker", ",", "err", ":=", "config", ".", "NewWorker", "(", "gate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "worker", ",", "nil", "\n\n", "}" ]

[ "start", "is", "a", "dependency", ".", "StartFunc", "that", "uses", "config", "." ]

[ "func", "FlagManifold", "(", "config", "FlagManifoldConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "GateName", "}", ",", "Start", ":", "config", ".", "start", ",", "Output", ":", "engine", ".", "FlagOutput", ",", "Filter", ":", "bounceUnlocked", ",", "}", "\n", "}" ]

[ "FlagManifold", "runs", "a", "worker", "that", "implements", "engine", ".", "Flag", "such", "that", "it", "s", "only", "considered", "set", "when", "the", "referenced", "gate", "is", "unlocked", "." ]

[ "func", "NewFlag", "(", "gate", "Waiter", ")", "(", "*", "Flag", ",", "error", ")", "{", "w", ":=", "&", "Flag", "{", "gate", ":", "gate", ",", "unlocked", ":", "gate", ".", "IsUnlocked", "(", ")", ",", "}", "\n", "w", ".", "tomb", ".", "Go", "(", "w", ".", "run", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "NewFlag", "returns", "a", "worker", "that", "implements", "engine", ".", "Flag", "backed", "by", "the", "supplied", "gate", "s", "unlockedness", "." ]

[ "func", "bounceUnlocked", "(", "err", "error", ")", "error", "{", "if", "errors", ".", "Cause", "(", "err", ")", "==", "ErrUnlocked", "{", "return", "dependency", ".", "ErrBounce", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "bounceUnlocked", "returns", "dependency", ".", "ErrBounce", "if", "passed", "an", "error", "caused", "by", "ErrUnlocked", ";", "and", "otherwise", "returns", "the", "original", "error", "." ]

[ "func", "(", "e", "*", "manualEnviron", ")", "Instances", "(", "ctx", "context", ".", "ProviderCallContext", ",", "ids", "[", "]", "instance", ".", "Id", ")", "(", "[", "]", "instances", ".", "Instance", ",", "error", ")", "{", "result", ":=", "make", "(", "[", "]", "instances", ".", "Instance", ",", "len", "(", "ids", ")", ")", "\n", "var", "found", "bool", "\n", "var", "err", "error", "\n", "for", "i", ",", "id", ":=", "range", "ids", "{", "if", "id", "==", "BootstrapInstanceId", "{", "result", "[", "i", "]", "=", "manualBootstrapInstance", "{", "e", ".", "host", "}", "\n", "found", "=", "true", "\n", "}", "else", "{", "err", "=", "environs", ".", "ErrPartialInstances", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "err", "=", "environs", ".", "ErrNoInstances", "\n", "}", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "Instances", "implements", "environs", ".", "Environ", ".", "This", "method", "will", "only", "ever", "return", "an", "Instance", "for", "the", "Id", "BootstrapInstanceId", ".", "If", "any", "others", "are", "specified", "then", "ErrPartialInstances", "or", "ErrNoInstances", "will", "result", "." ]

[ "func", "LogProgressCmd", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "string", "{", "msg", ":=", "utils", ".", "ShQuote", "(", "fmt", ".", "Sprintf", "(", "format", ",", "args", "...", ")", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "msg", ",", "progressFdEnvVar", ")", "\n", "}" ]

[ "LogProgressCmd", "will", "return", "a", "command", "to", "log", "the", "specified", "progress", "message", "to", "stderr", ";", "the", "resultant", "command", "should", "be", "added", "to", "the", "configuration", "as", "a", "runcmd", "or", "bootcmd", "as", "appropriate", ".", "If", "there", "are", "any", "uses", "of", "LogProgressCmd", "in", "a", "configuration", "the", "configuration", "MUST", "precede", "the", "command", "with", "the", "result", "of", "InitProgressCmd", "." ]

[ "func", "NewIsLeaderCommand", "(", "ctx", "Context", ")", "(", "cmd", ".", "Command", ",", "error", ")", "{", "return", "&", "isLeaderCommand", "{", "ctx", ":", "ctx", "}", ",", "nil", "\n", "}" ]

[ "NewIsLeaderCommand", "returns", "a", "new", "isLeaderCommand", "with", "the", "given", "context", "." ]

[ "func", "generateListFilesystemsOutput", "(", "ctx", "*", "cmd", ".", "Context", ",", "api", "StorageListAPI", ",", "ids", "[", "]", "string", ")", "(", "map", "[", "string", "]", "FilesystemInfo", ",", "error", ")", "{", "results", ",", "err", ":=", "api", ".", "ListFilesystems", "(", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// filter out valid output, if any", "var", "valid", "[", "]", "params", ".", "FilesystemDetails", "\n", "for", "_", ",", "result", ":=", "range", "results", "{", "if", "result", ".", "Error", "==", "nil", "{", "valid", "=", "append", "(", "valid", ",", "result", ".", "Result", "...", ")", "\n", "continue", "\n", "}", "\n", "// display individual error", "fmt", ".", "Fprintf", "(", "ctx", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "result", ".", "Error", ")", "\n", "}", "\n", "if", "len", "(", "valid", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "convertToFilesystemInfo", "(", "valid", ")", "\n", "}" ]

[ "generateListFilesystemOutput", "returns", "a", "map", "filesystem", "IDs", "to", "filesystem", "info" ]

[ "func", "convertToFilesystemInfo", "(", "all", "[", "]", "params", ".", "FilesystemDetails", ")", "(", "map", "[", "string", "]", "FilesystemInfo", ",", "error", ")", "{", "result", ":=", "make", "(", "map", "[", "string", "]", "FilesystemInfo", ")", "\n", "for", "_", ",", "one", ":=", "range", "all", "{", "filesystemTag", ",", "info", ",", "err", ":=", "createFilesystemInfo", "(", "one", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "result", "[", "filesystemTag", ".", "Id", "(", ")", "]", "=", "info", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "convertToFilesystemInfo", "returns", "a", "map", "of", "filesystem", "IDs", "to", "filesystem", "info", "." ]

[ "func", "NewStatusGetter", "(", "st", "state", ".", "EntityFinder", ",", "getCanAccess", "GetAuthFunc", ")", "*", "StatusGetter", "{", "return", "&", "StatusGetter", "{", "st", ":", "st", ",", "getCanAccess", ":", "getCanAccess", ",", "}", "\n", "}" ]

[ "NewStatusGetter", "returns", "a", "new", "StatusGetter", ".", "The", "GetAuthFunc", "will", "be", "used", "on", "each", "invocation", "of", "Status", "to", "determine", "current", "permissions", "." ]

[ "func", "(", "s", "*", "StatusGetter", ")", "Status", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "StatusResults", ",", "error", ")", "{", "result", ":=", "params", ".", "StatusResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "StatusResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "canAccess", ",", "err", ":=", "s", ".", "getCanAccess", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "StatusResults", "{", "}", ",", "err", "\n", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "!", "canAccess", "(", "tag", ")", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n", "result", ".", "Results", "[", "i", "]", "=", "s", ".", "getEntityStatus", "(", "tag", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Status", "returns", "the", "status", "of", "each", "given", "entity", "." ]

[ "func", "NewApplicationStatusGetter", "(", "st", "*", "state", ".", "State", ",", "getCanAccess", "GetAuthFunc", ",", "leadershipChecker", "leadership", ".", "Checker", ")", "*", "ApplicationStatusGetter", "{", "return", "&", "ApplicationStatusGetter", "{", "leadershipChecker", ":", "leadershipChecker", ",", "st", ":", "st", ",", "getCanAccess", ":", "getCanAccess", ",", "}", "\n", "}" ]

[ "NewApplicationStatusGetter", "returns", "a", "ApplicationStatusGetter", "." ]

[ "func", "(", "s", "*", "ApplicationStatusGetter", ")", "Status", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "ApplicationStatusResults", ",", "error", ")", "{", "result", ":=", "params", ".", "ApplicationStatusResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ApplicationStatusResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "canAccess", ",", "err", ":=", "s", ".", "getCanAccess", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ApplicationStatusResults", "{", "}", ",", "err", "\n", "}", "\n\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Entities", "{", "// TODO(fwereade): the auth is basically nonsense, and basically only", "// works by coincidence (and is happening at the wrong layer anyway).", "// Read carefully.", "// We \"know\" that arg.Tag is either the calling unit or its application", "// (because getCanAccess is authUnitOrApplication, and we'll fail out if", "// it isn't); and, in practice, it's always going to be the calling", "// unit (because, /sigh, we don't actually use application tags to refer", "// to applications in this method).", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "arg", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "!", "canAccess", "(", "tag", ")", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n", "unitTag", ",", "ok", ":=", "tag", ".", "(", "names", ".", "UnitTag", ")", "\n", "if", "!", "ok", "{", "// No matter what the canAccess says, if this entity is not", "// a unit, we say \"NO\".", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n", "unitId", ":=", "unitTag", ".", "Id", "(", ")", "\n\n", "// Now we have the unit, we can get the application that should have been", "// specified in the first place...", "applicationId", ",", "err", ":=", "names", ".", "UnitApplication", "(", "unitId", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "application", ",", "err", ":=", "s", ".", "st", ".", "Application", "(", "applicationId", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "// ...so we can check the unit's application leadership...", "token", ":=", "s", ".", "leadershipChecker", ".", "LeadershipCheck", "(", "applicationId", ",", "unitId", ")", "\n", "if", "err", ":=", "token", ".", "Check", "(", "0", ",", "nil", ")", ";", "err", "!=", "nil", "{", "// TODO(fwereade) this should probably be ErrPerm is certain cases,", "// but I don't think I implemented an exported ErrNotLeader. I", "// should have done, though.", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "// ...and collect the results.", "applicationStatus", ",", "unitStatuses", ",", "err", ":=", "application", ".", "ApplicationAndUnitsStatus", "(", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Application", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "result", ".", "Results", "[", "i", "]", ".", "Application", ".", "Status", "=", "applicationStatus", ".", "Status", ".", "String", "(", ")", "\n", "result", ".", "Results", "[", "i", "]", ".", "Application", ".", "Info", "=", "applicationStatus", ".", "Message", "\n", "result", ".", "Results", "[", "i", "]", ".", "Application", ".", "Data", "=", "applicationStatus", ".", "Data", "\n", "result", ".", "Results", "[", "i", "]", ".", "Application", ".", "Since", "=", "applicationStatus", ".", "Since", "\n\n", "result", ".", "Results", "[", "i", "]", ".", "Units", "=", "make", "(", "map", "[", "string", "]", "params", ".", "StatusResult", ",", "len", "(", "unitStatuses", ")", ")", "\n", "for", "uTag", ",", "r", ":=", "range", "unitStatuses", "{", "ur", ":=", "params", ".", "StatusResult", "{", "Status", ":", "r", ".", "Status", ".", "String", "(", ")", ",", "Info", ":", "r", ".", "Message", ",", "Data", ":", "r", ".", "Data", ",", "Since", ":", "r", ".", "Since", ",", "}", "\n", "result", ".", "Results", "[", "i", "]", ".", "Units", "[", "uTag", "]", "=", "ur", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Status", "returns", "the", "status", "of", "the", "Application", "for", "each", "given", "Unit", "tag", "." ]

[ "func", "EntityStatusFromState", "(", "statusInfo", "status", ".", "StatusInfo", ")", "params", ".", "EntityStatus", "{", "return", "params", ".", "EntityStatus", "{", "Status", ":", "statusInfo", ".", "Status", ",", "Info", ":", "statusInfo", ".", "Message", ",", "Data", ":", "statusInfo", ".", "Data", ",", "Since", ":", "statusInfo", ".", "Since", ",", "}", "\n", "}" ]

[ "EntityStatusFromState", "converts", "a", "state", ".", "StatusInfo", "into", "a", "params", ".", "EntityStatus", "." ]

[ "func", "NewErrWriter", "(", "w", "io", ".", "Writer", ")", "io", ".", "Writer", "{", "return", "errWriter", "{", "ansiterm", ".", "NewWriter", "(", "w", ")", "}", "\n", "}" ]

[ "NewErrWriter", "wraps", "w", "in", "a", "type", "that", "will", "cause", "all", "writes", "to", "be", "written", "as", "ansi", "terminal", "BrightRed", "." ]

[ "func", "(", "e", "*", "ebsProvider", ")", "Supports", "(", "k", "storage", ".", "StorageKind", ")", "bool", "{", "return", "k", "==", "storage", ".", "StorageKindBlock", "\n", "}" ]

[ "Supports", "is", "defined", "on", "the", "Provider", "interface", "." ]

[ "func", "(", "e", "*", "ebsProvider", ")", "DefaultPools", "(", ")", "[", "]", "*", "storage", ".", "Config", "{", "ssdPool", ",", "_", ":=", "storage", ".", "NewConfig", "(", "\"", "\"", ",", "EBS_ProviderType", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "EBS_VolumeType", ":", "volumeAliasSSD", ",", "}", ")", "\n", "return", "[", "]", "*", "storage", ".", "Config", "{", "ssdPool", "}", "\n", "}" ]

[ "DefaultPools", "is", "defined", "on", "the", "Provider", "interface", "." ]

[ "func", "parseVolumeOptions", "(", "size", "uint64", ",", "attrs", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "_", "ec2", ".", "CreateVolume", ",", "_", "error", ")", "{", "ebsConfig", ",", "err", ":=", "newEbsConfig", "(", "attrs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ec2", ".", "CreateVolume", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "ebsConfig", ".", "iops", ">", "maxProvisionedIopsSizeRatio", "{", "return", "ec2", ".", "CreateVolume", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "ebsConfig", ".", "iops", ",", "maxProvisionedIopsSizeRatio", ",", ")", "\n", "}", "\n\n", "sizeInGib", ":=", "mibToGib", "(", "size", ")", "\n", "iops", ":=", "uint64", "(", "ebsConfig", ".", "iops", ")", "*", "sizeInGib", "\n", "if", "iops", ">", "maxProvisionedIops", "{", "iops", "=", "maxProvisionedIops", "\n", "}", "\n", "vol", ":=", "ec2", ".", "CreateVolume", "{", "// Juju size is MiB, AWS size is GiB.", "VolumeSize", ":", "int", "(", "sizeInGib", ")", ",", "VolumeType", ":", "ebsConfig", ".", "volumeType", ",", "Encrypted", ":", "ebsConfig", ".", "encrypted", ",", "IOPS", ":", "int64", "(", "iops", ")", ",", "}", "\n", "return", "vol", ",", "nil", "\n", "}" ]

[ "parseVolumeOptions", "uses", "storage", "volume", "parameters", "to", "make", "a", "struct", "used", "to", "create", "volumes", "." ]

[ "func", "(", "config", "ManagerConfig", ")", "Validate", "(", ")", "error", "{", "if", "config", ".", "Secretary", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Store", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Logger", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Clock", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "MaxSleep", "<=", "0", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "// TODO: make the PrometheusRegisterer required when we no longer", "// have state workers managing leases.", "return", "nil", "\n", "}" ]

[ "Validate", "returns", "an", "error", "if", "the", "configuration", "contains", "invalid", "information", "or", "missing", "resources", "." ]

[ "func", "InstallBufferedLogWriter", "(", "maxLen", "int", ")", "(", "*", "BufferedLogWriter", ",", "error", ")", "{", "writer", ":=", "NewBufferedLogWriter", "(", "maxLen", ")", "\n", "err", ":=", "loggo", ".", "RegisterWriter", "(", "writerName", ",", "writer", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "writer", ",", "nil", "\n", "}" ]

[ "InstallBufferedLogWriter", "creates", "and", "returns", "a", "new", "BufferedLogWriter", "registering", "it", "with", "Loggo", "." ]

[ "func", "UninstallBufferedLogWriter", "(", ")", "error", "{", "writer", ",", "err", ":=", "loggo", ".", "RemoveWriter", "(", "writerName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "bufWriter", ",", "ok", ":=", "writer", ".", "(", "*", "BufferedLogWriter", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "bufWriter", ".", "Close", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "UninstallBufferedLogWriter", "removes", "the", "BufferedLogWriter", "previously", "installed", "by", "InstallBufferedLogWriter", "and", "closes", "it", "." ]

[ "func", "NewBufferedLogWriter", "(", "maxLen", "int", ")", "*", "BufferedLogWriter", "{", "w", ":=", "&", "BufferedLogWriter", "{", "maxLen", ":", "maxLen", ",", "in", ":", "make", "(", "LogRecordCh", ")", ",", "out", ":", "make", "(", "LogRecordCh", ")", ",", "}", "\n", "go", "w", ".", "loop", "(", ")", "\n", "return", "w", "\n", "}" ]

[ "NewBufferedLogWriter", "returns", "a", "new", "BufferedLogWriter", "which", "will", "cache", "up", "to", "maxLen", "log", "messages", "." ]

[ "func", "(", "w", "*", "BufferedLogWriter", ")", "Write", "(", "entry", "loggo", ".", "Entry", ")", "{", "w", ".", "in", "<-", "&", "LogRecord", "{", "Time", ":", "entry", ".", "Timestamp", ",", "Module", ":", "entry", ".", "Module", ",", "Location", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "filepath", ".", "Base", "(", "entry", ".", "Filename", ")", ",", "entry", ".", "Line", ")", ",", "Level", ":", "entry", ".", "Level", ",", "Message", ":", "entry", ".", "Message", ",", "}", "\n", "}" ]

[ "Write", "sends", "a", "new", "log", "message", "to", "the", "writer", ".", "This", "implements", "the", "loggo", ".", "Writer", "interface", "." ]

[ "func", "(", "w", "*", "BufferedLogWriter", ")", "Stats", "(", ")", "LogStats", "{", "w", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "w", ".", "stats", "\n", "}" ]

[ "Stats", "returns", "the", "current", "LogStats", "for", "this", "BufferedLogWriter", "." ]

[ "func", "(", "c", "*", "ItemChange", ")", "String", "(", ")", "string", "{", "switch", "c", ".", "Type", "{", "case", "added", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Key", ",", "c", ".", "NewValue", ")", "\n", "case", "modified", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Key", ",", "c", ".", "NewValue", ",", "c", ".", "OldValue", ")", "\n", "case", "deleted", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Key", ",", "c", ".", "OldValue", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Type", ",", "c", ".", "Key", ",", "c", ".", "NewValue", ",", "c", ".", "OldValue", ")", "\n", "}" ]

[ "String", "returns", "the", "item", "change", "in", "a", "readable", "format", "." ]

[ "func", "MakeAddition", "(", "key", "string", ",", "newVal", "interface", "{", "}", ")", "ItemChange", "{", "return", "ItemChange", "{", "Type", ":", "added", ",", "Key", ":", "key", ",", "NewValue", ":", "newVal", ",", "}", "\n", "}" ]

[ "MakeAddition", "returns", "an", "itemChange", "indicating", "a", "modification", "of", "the", "input", "key", "with", "its", "new", "value", "." ]

[ "func", "MakeModification", "(", "key", "string", ",", "oldVal", ",", "newVal", "interface", "{", "}", ")", "ItemChange", "{", "return", "ItemChange", "{", "Type", ":", "modified", ",", "Key", ":", "key", ",", "OldValue", ":", "oldVal", ",", "NewValue", ":", "newVal", ",", "}", "\n", "}" ]

[ "MakeModification", "returns", "an", "ItemChange", "indicating", "a", "modification", "of", "the", "input", "key", "with", "its", "old", "and", "new", "values", "." ]

[ "func", "MakeDeletion", "(", "key", "string", ",", "oldVal", "interface", "{", "}", ")", "ItemChange", "{", "return", "ItemChange", "{", "Type", ":", "deleted", ",", "Key", ":", "key", ",", "OldValue", ":", "oldVal", ",", "}", "\n", "}" ]

[ "MakeDeletion", "returns", "an", "ItemChange", "indicating", "a", "deletion", "of", "the", "input", "key", "with", "its", "old", "value", "." ]

[ "func", "(", "c", "ItemChanges", ")", "ApplyDeltaSource", "(", "oldChanges", "ItemChanges", ")", "(", "ItemChanges", ",", "error", ")", "{", "m", ",", "err", ":=", "oldChanges", ".", "Map", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "res", ":=", "make", "(", "ItemChanges", ",", "len", "(", "c", ")", ")", "\n", "copy", "(", "res", ",", "c", ")", "\n\n", "for", "i", ",", "ch", ":=", "range", "res", "{", "if", "old", ",", "ok", ":=", "m", "[", "ch", ".", "Key", "]", ";", "ok", "{", "switch", "{", "case", "old", ".", "OldValue", "==", "nil", "&&", "ch", ".", "IsModification", "(", ")", ":", "// Any previous change with no old value indicates that the key", "// was not defined in settings when the branch was created.", "// Indicate the modification as an addition.", "res", "[", "i", "]", "=", "MakeAddition", "(", "ch", ".", "Key", ",", "ch", ".", "NewValue", ")", "\n", "case", "old", ".", "OldValue", "!=", "nil", "&&", "c", "[", "i", "]", ".", "IsAddition", "(", ")", ":", "// If a setting that existed at branch creation time has been", "// deleted and re-added, indicate it as a modification.", "res", "[", "i", "]", "=", "MakeModification", "(", "ch", ".", "Key", ",", "old", ".", "OldValue", ",", "ch", ".", "NewValue", ")", "\n", "default", ":", "// Preserve all old values.", "res", "[", "i", "]", ".", "OldValue", "=", "old", ".", "OldValue", "\n", "}", "\n\n", "// Remove the map entry to indicate we have dealt with the key.", "delete", "(", "m", ",", "ch", ".", "Key", ")", "\n", "}", "\n", "}", "\n\n", "// If there is an old change not present in this collection,", "// then we know that the setting was reset to its original value.", "// If this setting is subsequently reinstated, it is possible to lose the", "// original \"from\" value if master is updated in the meantime.", "// So we maintain a no-op entry (same from/to) in order to retain the old", "// value from when the configuration setting was first touched.", "// These values are not shown to an operator who views a \"diff\"", "// for the branch.", "for", "key", ",", "old", ":=", "range", "m", "{", "res", "=", "append", "(", "res", ",", "MakeModification", "(", "key", ",", "old", ".", "OldValue", ",", "old", ".", "OldValue", ")", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "ApplyDeltaSource", "uses", "this", "second", "-", "order", "delta", "to", "generate", "a", "first", "-", "older", "delta", ".", "It", "accepts", "a", "collection", "of", "changes", "representing", "a", "previous", "state", ".", "These", "are", "combined", "with", "the", "current", "changes", "to", "generate", "a", "new", "collection", ".", "It", "addresses", "a", "requirement", "that", "each", "branch", "change", "should", "represent", "the", "from", "state", "of", "master", "config", "at", "the", "time", "it", "is", "first", "created", "." ]

[ "func", "(", "c", "ItemChanges", ")", "CurrentSettings", "(", "defaults", "charm", ".", "Settings", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "result", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "_", ",", "change", ":=", "range", "c", "{", "key", ":=", "change", ".", "Key", "\n\n", "switch", "{", "case", "change", ".", "IsModification", "(", ")", "&&", "reflect", ".", "DeepEqual", "(", "change", ".", "OldValue", ",", "change", ".", "NewValue", ")", ":", "// These are placeholders that we do not apply.", "// See comment in ApplyDeltaSource, above.", "case", "change", ".", "IsDeletion", "(", ")", ":", "result", "[", "key", "]", "=", "defaults", "[", "key", "]", "\n", "default", ":", "result", "[", "key", "]", "=", "change", ".", "NewValue", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "CurrentSettings", "returns", "the", "current", "effective", "values", "indicated", "by", "this", "set", "of", "changes", ".", "It", "uses", "the", "input", "default", "settings", "to", "return", "a", "value", "for", "items", "that", "have", "been", "deleted", "." ]

[ "func", "(", "c", "ItemChanges", ")", "Map", "(", ")", "(", "map", "[", "string", "]", "ItemChange", ",", "error", ")", "{", "m", ":=", "make", "(", "map", "[", "string", "]", "ItemChange", ",", "len", "(", "c", ")", ")", "\n", "for", "_", ",", "ch", ":=", "range", "c", "{", "k", ":=", "ch", ".", "Key", "\n", "if", "_", ",", "ok", ":=", "m", "[", "k", "]", ";", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "m", "[", "k", "]", "=", "ch", "\n", "}", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "Map", "is", "a", "convenience", "method", "for", "working", "with", "collections", "of", "changes", ".", "It", "returns", "a", "map", "representation", "of", "the", "change", "collection", "indexed", "with", "the", "change", "key", ".", "An", "error", "return", "indicates", "that", "the", "collection", "had", "duplicate", "keys", "." ]

[ "func", "newAuthContext", "(", "st", "*", "state", ".", "State", ",", "clock", "clock", ".", "Clock", ",", ")", "(", "*", "authContext", ",", "error", ")", "{", "ctxt", ":=", "&", "authContext", "{", "st", ":", "st", ",", "clock", ":", "clock", ",", "localUserInteractions", ":", "authentication", ".", "NewInteractions", "(", ")", ",", "}", "\n\n", "// Create a bakery service for discharging third-party caveats for", "// local user authentication. This service does not persist keys;", "// its macaroons should be very short-lived.", "localUserThirdPartyBakeryService", ",", "_", ",", "err", ":=", "bakeryutil", ".", "NewBakeryService", "(", "st", ",", "nil", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ctxt", ".", "localUserThirdPartyBakeryService", "=", "localUserThirdPartyBakeryService", "\n\n", "// Create a bakery service for local user authentication. This service", "// persists keys into MongoDB in a TTL collection.", "store", ",", "err", ":=", "st", ".", "NewBakeryStorage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "locator", ":=", "bakeryutil", ".", "BakeryServicePublicKeyLocator", "{", "ctxt", ".", "localUserThirdPartyBakeryService", "}", "\n", "localUserBakeryService", ",", "localUserBakeryServiceKey", ",", "err", ":=", "bakeryutil", ".", "NewBakeryService", "(", "st", ",", "store", ",", "locator", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ctxt", ".", "localUserBakeryService", "=", "&", "bakeryutil", ".", "ExpirableStorageBakeryService", "{", "localUserBakeryService", ",", "localUserBakeryServiceKey", ",", "store", ",", "locator", ",", "}", "\n", "return", "ctxt", ",", "nil", "\n", "}" ]

[ "newAuthContext", "creates", "a", "new", "authentication", "context", "for", "st", "." ]

[ "func", "(", "ctxt", "*", "authContext", ")", "authenticator", "(", "serverHost", "string", ")", "authenticator", "{", "return", "authenticator", "{", "ctxt", ":", "ctxt", ",", "serverHost", ":", "serverHost", "}", "\n", "}" ]

[ "authenticator", "returns", "an", "authenticator", ".", "EntityAuthenticator", "for", "the", "API", "connection", "associated", "with", "the", "specified", "API", "server", "host", "." ]

[ "func", "(", "a", "authenticator", ")", "Authenticate", "(", "entityFinder", "authentication", ".", "EntityFinder", ",", "tag", "names", ".", "Tag", ",", "req", "params", ".", "LoginRequest", ",", ")", "(", "state", ".", "Entity", ",", "error", ")", "{", "auth", ",", "err", ":=", "a", ".", "authenticatorForTag", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "auth", ".", "Authenticate", "(", "entityFinder", ",", "tag", ",", "req", ")", "\n", "}" ]

[ "Authenticate", "implements", "authentication", ".", "EntityAuthenticator", "by", "choosing", "the", "right", "kind", "of", "authentication", "for", "the", "given", "tag", "." ]

[ "func", "(", "a", "authenticator", ")", "authenticatorForTag", "(", "tag", "names", ".", "Tag", ")", "(", "authentication", ".", "EntityAuthenticator", ",", "error", ")", "{", "if", "tag", "==", "nil", "{", "auth", ",", "err", ":=", "a", ".", "ctxt", ".", "externalMacaroonAuth", "(", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "errMacaroonAuthNotConfigured", "{", "err", "=", "errors", ".", "Trace", "(", "common", ".", "ErrNoCreds", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "auth", ",", "nil", "\n", "}", "\n", "switch", "tag", ".", "Kind", "(", ")", "{", "case", "names", ".", "UnitTagKind", ",", "names", ".", "MachineTagKind", ",", "names", ".", "ApplicationTagKind", ":", "return", "&", "a", ".", "ctxt", ".", "agentAuth", ",", "nil", "\n", "case", "names", ".", "UserTagKind", ":", "return", "a", ".", "localUserAuth", "(", ")", ",", "nil", "\n", "default", ":", "return", "nil", ",", "errors", ".", "Annotatef", "(", "common", ".", "ErrBadRequest", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "authenticatorForTag", "returns", "the", "authenticator", "appropriate", "to", "use", "for", "a", "login", "with", "the", "given", "possibly", "-", "nil", "tag", "." ]

[ "func", "(", "a", "authenticator", ")", "localUserAuth", "(", ")", "*", "authentication", ".", "UserAuthenticator", "{", "localUserIdentityLocation", ":=", "url", ".", "URL", "{", "Scheme", ":", "\"", "\"", ",", "Host", ":", "a", ".", "serverHost", ",", "Path", ":", "localUserIdentityLocationPath", ",", "}", "\n", "return", "&", "authentication", ".", "UserAuthenticator", "{", "Service", ":", "a", ".", "ctxt", ".", "localUserBakeryService", ",", "Clock", ":", "a", ".", "ctxt", ".", "clock", ",", "LocalUserIdentityLocation", ":", "localUserIdentityLocation", ".", "String", "(", ")", ",", "}", "\n", "}" ]

[ "localUserAuth", "returns", "an", "authenticator", "that", "can", "authenticate", "logins", "for", "local", "users", "with", "either", "passwords", "or", "macaroons", "." ]

[ "func", "(", "ctxt", "*", "authContext", ")", "externalMacaroonAuth", "(", ")", "(", "authentication", ".", "EntityAuthenticator", ",", "error", ")", "{", "ctxt", ".", "macaroonAuthOnce", ".", "Do", "(", "func", "(", ")", "{", "ctxt", ".", "_macaroonAuth", ",", "ctxt", ".", "_macaroonAuthError", "=", "newExternalMacaroonAuth", "(", "ctxt", ".", "st", ")", "\n", "}", ")", "\n", "if", "ctxt", ".", "_macaroonAuth", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "ctxt", ".", "_macaroonAuthError", ")", "\n", "}", "\n", "return", "ctxt", ".", "_macaroonAuth", ",", "nil", "\n", "}" ]

[ "externalMacaroonAuth", "returns", "an", "authenticator", "that", "can", "authenticate", "macaroon", "-", "based", "logins", "for", "external", "users", ".", "If", "it", "fails", "once", "it", "will", "always", "fail", "." ]

[ "func", "newExternalMacaroonAuth", "(", "st", "*", "state", ".", "State", ")", "(", "*", "authentication", ".", "ExternalMacaroonAuthenticator", ",", "error", ")", "{", "controllerCfg", ",", "err", ":=", "st", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "idURL", ":=", "controllerCfg", ".", "IdentityURL", "(", ")", "\n", "if", "idURL", "==", "\"", "\"", "{", "return", "nil", ",", "errMacaroonAuthNotConfigured", "\n", "}", "\n", "var", "locator", "bakery", ".", "PublicKeyLocator", "\n", "// The identity server has been configured,", "// so configure the bakery service appropriately.", "idPK", ":=", "controllerCfg", ".", "IdentityPublicKey", "(", ")", "\n", "if", "idPK", "!=", "nil", "{", "locator", "=", "bakery", ".", "PublicKeyLocatorMap", "{", "idURL", ":", "idPK", "}", "\n", "}", "else", "{", "// No public key supplied - retrieve it from the identity manager on demand.", "// Note that we don't fetch it immediately because then we'll fail", "// forever if the initial fetch fails (because newExternalMacaroonAuth", "// only ever called once).", "locator", "=", "httpbakery", ".", "NewPublicKeyRing", "(", "nil", ",", "nil", ")", "\n", "}", "\n", "// We pass in nil for the storage, which leads to in-memory storage", "// being used. We only use in-memory storage for now, since we never", "// expire the keys, and don't want garbage to accumulate.", "//", "// TODO(axw) we should store the key in mongo, so that multiple servers", "// can authenticate. That will require that we encode the server's ID", "// in the macaroon ID so that servers don't overwrite each others' keys.", "svc", ",", "_", ",", "err", ":=", "bakeryutil", ".", "NewBakeryService", "(", "st", ",", "nil", ",", "locator", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "var", "auth", "authentication", ".", "ExternalMacaroonAuthenticator", "\n", "auth", ".", "Service", "=", "svc", "\n", "auth", ".", "Macaroon", ",", "err", "=", "svc", ".", "NewMacaroon", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "auth", ".", "IdentityLocation", "=", "idURL", "\n", "return", "&", "auth", ",", "nil", "\n", "}" ]

[ "newExternalMacaroonAuth", "returns", "an", "authenticator", "that", "can", "authenticate", "macaroon", "-", "based", "logins", "for", "external", "users", ".", "This", "is", "just", "a", "helper", "function", "for", "authCtxt", ".", "externalMacaroonAuth", "." ]

[ "func", "(", "m", "*", "Model", ")", "LoadModelStatus", "(", ")", "(", "*", "ModelStatus", ",", "error", ")", "{", "statuses", ",", "closer", ":=", "m", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "statusesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "docs", "[", "]", "statusDocWithID", "\n", "err", ":=", "statuses", ".", "Find", "(", "nil", ")", ".", "All", "(", "&", "docs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "result", ":=", "&", "ModelStatus", "{", "model", ":", "m", ",", "docs", ":", "make", "(", "map", "[", "string", "]", "statusDocWithID", ")", ",", "}", "\n", "for", "_", ",", "doc", ":=", "range", "docs", "{", "id", ":=", "m", ".", "localID", "(", "doc", ".", "ID", ")", "\n", "result", ".", "docs", "[", "id", "]", "=", "doc", "\n", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "LoadModelStatus", "retrieves", "all", "the", "status", "documents", "for", "the", "model", "at", "once", ".", "Used", "to", "primarily", "speed", "up", "status", "." ]

[ "func", "(", "m", "*", "ModelStatus", ")", "Model", "(", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "m", ".", "getStatus", "(", "m", ".", "model", ".", "globalKey", "(", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "Model", "returns", "the", "status", "of", "the", "model", "." ]

[ "func", "(", "m", "*", "ModelStatus", ")", "MachineAgent", "(", "machineID", "string", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "m", ".", "getStatus", "(", "machineGlobalKey", "(", "machineID", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "MachineAgent", "returns", "the", "status", "of", "the", "machine", "agent", "." ]

[ "func", "(", "m", "*", "ModelStatus", ")", "MachineInstance", "(", "machineID", "string", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "m", ".", "getStatus", "(", "machineGlobalInstanceKey", "(", "machineID", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "MachineInstance", "returns", "the", "status", "of", "the", "machine", "instance", "." ]

[ "func", "(", "m", "*", "ModelStatus", ")", "MachineModification", "(", "machineID", "string", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "m", ".", "getStatus", "(", "machineGlobalModificationKey", "(", "machineID", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "MachineModification", "returns", "the", "status", "of", "the", "machine", "modification" ]

[ "func", "(", "m", "*", "ModelStatus", ")", "FullUnitWorkloadVersion", "(", "unitName", "string", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "m", ".", "getStatus", "(", "globalWorkloadVersionKey", "(", "unitName", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "FullUnitWorkloadVersion", "returns", "the", "full", "status", "info", "for", "the", "workload", "version", "of", "a", "unit", ".", "This", "is", "used", "for", "selecting", "the", "workload", "version", "for", "an", "application", "." ]

[ "func", "(", "m", "*", "ModelStatus", ")", "UnitWorkloadVersion", "(", "unitName", "string", ")", "(", "string", ",", "error", ")", "{", "info", ",", "err", ":=", "m", ".", "getStatus", "(", "globalWorkloadVersionKey", "(", "unitName", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "info", ".", "Message", ",", "nil", "\n", "}" ]

[ "UnitWorkloadVersion", "returns", "workload", "version", "for", "the", "unit" ]

[ "func", "(", "m", "*", "ModelStatus", ")", "UnitAgent", "(", "unitName", "string", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "// We do horrible things with unit status.", "// See notes in unitagent.go.", "info", ",", "err", ":=", "m", ".", "getStatus", "(", "unitAgentGlobalKey", "(", "unitName", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "info", ",", "err", "\n", "}", "\n", "if", "info", ".", "Status", "==", "status", ".", "Error", "{", "return", "status", ".", "StatusInfo", "{", "Status", ":", "status", ".", "Idle", ",", "Message", ":", "\"", "\"", ",", "Data", ":", "map", "[", "string", "]", "interface", "{", "}", "{", "}", ",", "Since", ":", "info", ".", "Since", ",", "}", ",", "nil", "\n", "}", "\n", "return", "info", ",", "nil", "\n", "}" ]

[ "UnitAgent", "returns", "the", "status", "of", "the", "Unit", "s", "agent", "." ]

[ "func", "(", "m", "*", "ModelStatus", ")", "UnitWorkload", "(", "unitName", "string", ",", "expectWorkload", "bool", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "// We do horrible things with unit status.", "// See notes in unit.go.", "info", ",", "err", ":=", "m", ".", "getStatus", "(", "unitAgentGlobalKey", "(", "unitName", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "info", ",", "err", "\n", "}", "else", "if", "info", ".", "Status", "==", "status", ".", "Error", "{", "return", "info", ",", "nil", "\n", "}", "\n\n", "// (for CAAS models) Use cloud container status over unit if the cloud", "// container status is error or active or the unit status hasn't shifted", "// from 'allocating'", "info", ",", "err", "=", "m", ".", "getStatus", "(", "unitGlobalKey", "(", "unitName", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "info", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "m", ".", "model", ".", "Type", "(", ")", "==", "ModelTypeIAAS", "{", "return", "info", ",", "nil", "\n", "}", "\n\n", "containerInfo", ",", "err", ":=", "m", ".", "getStatus", "(", "globalCloudContainerKey", "(", "unitName", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "info", ",", "err", "\n", "}", "\n", "return", "caasUnitDisplayStatus", "(", "info", ",", "containerInfo", ",", "expectWorkload", ")", ",", "nil", "\n", "}" ]

[ "UnitWorkload", "returns", "the", "status", "of", "the", "unit", "s", "workload", "." ]

[ "func", "caasApplicationDisplayStatus", "(", "applicationStatus", ",", "operatorStatus", "status", ".", "StatusInfo", ",", "expectWorkload", "bool", ")", "status", ".", "StatusInfo", "{", "if", "applicationStatus", ".", "Status", "==", "status", ".", "Terminated", "{", "return", "applicationStatus", "\n", "}", "\n", "// Only interested in the operator status if it's not running/active.", "if", "operatorStatus", ".", "Status", "!=", "status", ".", "Running", "&&", "operatorStatus", ".", "Status", "!=", "status", ".", "Active", "{", "if", "operatorStatus", ".", "Status", "==", "status", ".", "Waiting", "&&", "!", "expectWorkload", "{", "operatorStatus", ".", "Message", "=", "status", ".", "MessageInitializingAgent", "\n", "}", "\n", "return", "operatorStatus", "\n", "}", "\n\n", "return", "applicationStatus", "\n", "}" ]

[ "caasApplicationDisplayStatus", "determines", "which", "of", "the", "two", "statuses", "to", "use", "when", "displaying", "application", "status", "in", "a", "CAAS", "model", "." ]

[ "func", "caasHistoryRewriteDoc", "(", "jujuStatus", ",", "caasStatus", "status", ".", "StatusInfo", ",", "expectWorkload", "bool", ",", "displayStatus", "displayStatusFunc", ",", "clock", "clock", ".", "Clock", ")", "(", "*", "statusDoc", ",", "error", ")", "{", "modifiedStatus", ":=", "displayStatus", "(", "jujuStatus", ",", "caasStatus", ",", "expectWorkload", ")", "\n", "if", "modifiedStatus", ".", "Status", "==", "jujuStatus", ".", "Status", "&&", "modifiedStatus", ".", "Message", "==", "jujuStatus", ".", "Message", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "&", "statusDoc", "{", "Status", ":", "modifiedStatus", ".", "Status", ",", "StatusInfo", ":", "modifiedStatus", ".", "Message", ",", "StatusData", ":", "utils", ".", "EscapeKeys", "(", "modifiedStatus", ".", "Data", ")", ",", "Updated", ":", "timeOrNow", "(", "modifiedStatus", ".", "Since", ",", "clock", ")", ".", "UnixNano", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "caasHistoryRewriteDoc", "determines", "which", "status", "should", "be", "stored", "as", "history", "." ]

[ "func", "getStatus", "(", "db", "Database", ",", "globalKey", ",", "badge", "string", ")", "(", "_", "status", ".", "StatusInfo", ",", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ")", "\n", "statuses", ",", "closer", ":=", "db", ".", "GetCollection", "(", "statusesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "doc", "statusDoc", "\n", "err", "=", "statuses", ".", "FindId", "(", "globalKey", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "status", ".", "StatusInfo", "{", "}", ",", "errors", ".", "NotFoundf", "(", "badge", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "status", ".", "StatusInfo", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "status", ".", "StatusInfo", "{", "Status", ":", "doc", ".", "Status", ",", "Message", ":", "doc", ".", "StatusInfo", ",", "Data", ":", "utils", ".", "UnescapeKeys", "(", "doc", ".", "StatusData", ")", ",", "Since", ":", "unixNanoToTime", "(", "doc", ".", "Updated", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "getStatus", "retrieves", "the", "status", "document", "associated", "with", "the", "given", "globalKey", "and", "converts", "it", "to", "a", "StatusInfo", ".", "If", "the", "status", "document", "is", "not", "found", "a", "NotFoundError", "referencing", "badge", "will", "be", "returned", "." ]

[ "func", "setStatus", "(", "db", "Database", ",", "params", "setStatusParams", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ")", "\n", "if", "params", ".", "updated", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "doc", ":=", "statusDoc", "{", "Status", ":", "params", ".", "status", ",", "StatusInfo", ":", "params", ".", "message", ",", "StatusData", ":", "utils", ".", "EscapeKeys", "(", "params", ".", "rawData", ")", ",", "Updated", ":", "params", ".", "updated", ".", "UnixNano", "(", ")", ",", "}", "\n\n", "historyDoc", ":=", "&", "doc", "\n", "if", "params", ".", "historyOverwrite", "!=", "nil", "{", "historyDoc", "=", "params", ".", "historyOverwrite", "\n", "}", "\n\n", "newStatus", ",", "historyErr", ":=", "probablyUpdateStatusHistory", "(", "db", ",", "params", ".", "globalKey", ",", "*", "historyDoc", ")", "\n", "if", "params", ".", "historyOverwrite", "==", "nil", "&&", "(", "!", "newStatus", "&&", "historyErr", "==", "nil", ")", "{", "// If this status is not new (i.e. it is exactly the same as", "// our last status), there is no need to update the record.", "// Update here will only reset the 'Since' field.", "return", "err", "\n", "}", "\n\n", "// Set the authoritative status document, or fail trying.", "var", "buildTxn", "jujutxn", ".", "TransactionSource", "=", "func", "(", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "return", "statusSetOps", "(", "db", ",", "doc", ",", "params", ".", "globalKey", ")", "\n", "}", "\n", "if", "params", ".", "token", "!=", "nil", "{", "buildTxn", "=", "buildTxnWithLeadership", "(", "buildTxn", ",", "params", ".", "token", ")", "\n", "}", "\n", "err", "=", "db", ".", "Run", "(", "buildTxn", ")", "\n", "if", "cause", ":=", "errors", ".", "Cause", "(", "err", ")", ";", "cause", "==", "mgo", ".", "ErrNotFound", "{", "return", "errors", ".", "NotFoundf", "(", "params", ".", "badge", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "setStatus", "inteprets", "the", "supplied", "params", "as", "documented", "on", "the", "type", "." ]

[ "func", "createStatusOp", "(", "mb", "modelBackend", ",", "globalKey", "string", ",", "doc", "statusDoc", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "statusesC", ",", "Id", ":", "mb", ".", "docID", "(", "globalKey", ")", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "&", "doc", ",", "}", "\n", "}" ]

[ "createStatusOp", "returns", "the", "operation", "needed", "to", "create", "the", "given", "status", "document", "associated", "with", "the", "given", "globalKey", "." ]

[ "func", "removeStatusOp", "(", "mb", "modelBackend", ",", "globalKey", "string", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "statusesC", ",", "Id", ":", "mb", ".", "docID", "(", "globalKey", ")", ",", "Remove", ":", "true", ",", "}", "\n", "}" ]

[ "removeStatusOp", "returns", "the", "operation", "needed", "to", "remove", "the", "status", "document", "associated", "with", "the", "given", "globalKey", "." ]

[ "func", "probablyUpdateStatusHistory", "(", "db", "Database", ",", "globalKey", "string", ",", "doc", "statusDoc", ")", "(", "bool", ",", "error", ")", "{", "historyDoc", ":=", "&", "historicalStatusDoc", "{", "Status", ":", "doc", ".", "Status", ",", "StatusInfo", ":", "doc", ".", "StatusInfo", ",", "StatusData", ":", "doc", ".", "StatusData", ",", "// coming from a statusDoc, already escaped", "Updated", ":", "doc", ".", "Updated", ",", "GlobalKey", ":", "globalKey", ",", "}", "\n", "history", ",", "closer", ":=", "db", ".", "GetCollection", "(", "statusesHistoryC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "exists", ",", "currentID", ":=", "statusHistoryExists", "(", "db", ",", "historyDoc", ")", "\n", "if", "exists", "{", "// If the status values have not changed since the last run,", "// update history record with this timestamp", "// to keep correct track of when SetStatus ran.", "historyW", ":=", "history", ".", "Writeable", "(", ")", "\n", "err", ":=", "historyW", ".", "Update", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "currentID", "}", "}", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "doc", ".", "Updated", "}", "}", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}", "\n\n", "historyW", ":=", "history", ".", "Writeable", "(", ")", "\n", "err", ":=", "historyW", ".", "Insert", "(", "historyDoc", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "probablyUpdateStatusHistory", "inspects", "existing", "status", "-", "history", "and", "determines", "if", "this", "status", "is", "new", "or", "the", "same", "as", "the", "last", "recorded", ".", "If", "this", "is", "a", "new", "status", "a", "new", "status", "history", "record", "will", "be", "added", ".", "If", "this", "status", "is", "the", "same", "as", "the", "last", "status", "we", "ve", "received", "we", "update", "that", "record", "to", "have", "a", "new", "timestamp", ".", "Status", "messages", "are", "considered", "to", "be", "the", "same", "if", "they", "only", "differ", "in", "their", "timestamps", ".", "The", "call", "returns", "true", "if", "a", "new", "status", "history", "record", "has", "been", "created", "." ]

[ "func", "eraseStatusHistory", "(", "mb", "modelBackend", ",", "globalKey", "string", ")", "error", "{", "// TODO(axw) restructure status history so we have one", "// document per global key, and sub-documents per status", "// recording. This method would then become a single", "// Remove operation.", "history", ",", "closer", ":=", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "statusesHistoryC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "iter", ":=", "history", ".", "Find", "(", "bson", ".", "D", "{", "{", "globalKeyField", ",", "globalKey", ",", "}", "}", ")", ".", "Select", "(", "bson", ".", "M", "{", "\"", "\"", ":", "1", "}", ")", ".", "Iter", "(", ")", "\n", "defer", "iter", ".", "Close", "(", ")", "\n\n", "logFormat", ":=", "\"", "\"", "+", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "globalKey", ")", "\n", "deleted", ",", "err", ":=", "deleteInBatches", "(", "history", ".", "Writeable", "(", ")", ".", "Underlying", "(", ")", ",", "iter", ",", "logFormat", ",", "loggo", ".", "DEBUG", ",", "noEarlyFinish", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "deleted", ">", "0", "{", "logger", ".", "Debugf", "(", "logFormat", ",", "deleted", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "eraseStatusHistory", "removes", "all", "status", "history", "documents", "for", "the", "given", "global", "key", ".", "The", "documents", "are", "removed", "in", "batches", "to", "avoid", "locking", "the", "status", "history", "collection", "for", "extended", "periods", "of", "time", "preventing", "status", "history", "being", "recorded", "for", "other", "entities", "." ]

[ "func", "fetchNStatusResults", "(", "col", "mongo", ".", "Collection", ",", "key", "string", ",", "filter", "status", ".", "StatusHistoryFilter", ")", "(", "[", "]", "historicalStatusDoc", ",", "error", ")", "{", "var", "(", "docs", "[", "]", "historicalStatusDoc", "\n", "query", "mongo", ".", "Query", "\n", ")", "\n", "baseQuery", ":=", "bson", ".", "M", "{", "\"", "\"", ":", "key", "}", "\n", "if", "filter", ".", "Delta", "!=", "nil", "{", "delta", ":=", "*", "filter", ".", "Delta", "\n", "// TODO(perrito666) 2016-10-06 lp:1558657", "updated", ":=", "time", ".", "Now", "(", ")", ".", "Add", "(", "-", "delta", ")", "\n", "baseQuery", "[", "\"", "\"", "]", "=", "bson", ".", "M", "{", "\"", "\"", ":", "updated", ".", "UnixNano", "(", ")", "}", "\n", "}", "\n", "if", "filter", ".", "FromDate", "!=", "nil", "{", "baseQuery", "[", "\"", "\"", "]", "=", "bson", ".", "M", "{", "\"", "\"", ":", "filter", ".", "FromDate", ".", "UnixNano", "(", ")", "}", "\n", "}", "\n", "excludes", ":=", "[", "]", "string", "{", "}", "\n", "excludes", "=", "append", "(", "excludes", ",", "filter", ".", "Exclude", ".", "Values", "(", ")", "...", ")", "\n", "if", "len", "(", "excludes", ")", ">", "0", "{", "baseQuery", "[", "\"", "\"", "]", "=", "bson", ".", "M", "{", "\"", "\"", ":", "excludes", "}", "\n", "}", "\n\n", "query", "=", "col", ".", "Find", "(", "baseQuery", ")", ".", "Sort", "(", "\"", "\"", ")", "\n", "if", "filter", ".", "Size", ">", "0", "{", "query", "=", "query", ".", "Limit", "(", "filter", ".", "Size", ")", "\n", "}", "\n", "err", ":=", "query", ".", "All", "(", "&", "docs", ")", "\n\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "[", "]", "historicalStatusDoc", "{", "}", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "[", "]", "historicalStatusDoc", "{", "}", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "docs", ",", "nil", "\n\n", "}" ]

[ "fetchNStatusResults", "will", "return", "status", "for", "the", "given", "key", "filtered", "with", "the", "given", "filter", "or", "error", "." ]

[ "func", "NewStorageAPI", "(", "context", "facade", ".", "Context", ")", "(", "*", "StorageAPI", ",", "error", ")", "{", "st", ":=", "context", ".", "State", "(", ")", "\n", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "registry", ",", "err", ":=", "stateenvirons", ".", "NewStorageProviderRegistryForModel", "(", "model", ",", "stateenvirons", ".", "GetNewEnvironFunc", "(", "environs", ".", "New", ")", ",", "stateenvirons", ".", "GetNewCAASBrokerFunc", "(", "caas", ".", "New", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "pm", ":=", "poolmanager", ".", "New", "(", "state", ".", "NewStateSettings", "(", "st", ")", ",", "registry", ")", "\n\n", "storageAccessor", ",", "err", ":=", "getStorageAccessor", "(", "st", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "authorizer", ":=", "context", ".", "Auth", "(", ")", "\n", "if", "!", "authorizer", ".", "AuthClient", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "newStorageAPI", "(", "stateShim", "{", "st", "}", ",", "model", ".", "Type", "(", ")", ",", "storageAccessor", ",", "registry", ",", "pm", ",", "authorizer", ",", "state", ".", "CallContext", "(", "st", ")", ")", ",", "nil", "\n", "}" ]

[ "NewStorageAPI", "returns", "a", "new", "storage", "API", "facade", "." ]

[ "func", "NewStorageAPIV5", "(", "context", "facade", ".", "Context", ")", "(", "*", "StorageAPIv5", ",", "error", ")", "{", "storageAPI", ",", "err", ":=", "NewStorageAPI", "(", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "StorageAPIv5", "{", "StorageAPI", ":", "*", "storageAPI", ",", "}", ",", "nil", "\n", "}" ]

[ "NewStorageAPIV5", "returns", "a", "new", "storage", "v5", "API", "facade", "." ]

[ "func", "NewStorageAPIV4", "(", "context", "facade", ".", "Context", ")", "(", "*", "StorageAPIv4", ",", "error", ")", "{", "storageAPI", ",", "err", ":=", "NewStorageAPIV5", "(", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "StorageAPIv4", "{", "StorageAPIv5", ":", "*", "storageAPI", ",", "}", ",", "nil", "\n", "}" ]

[ "NewStorageAPIV4", "returns", "a", "new", "storage", "v4", "API", "facade", "." ]

[ "func", "NewStorageAPIV3", "(", "context", "facade", ".", "Context", ")", "(", "*", "StorageAPIv3", ",", "error", ")", "{", "storageAPI", ",", "err", ":=", "NewStorageAPIV4", "(", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "StorageAPIv3", "{", "StorageAPIv4", ":", "*", "storageAPI", ",", "}", ",", "nil", "\n", "}" ]

[ "NewStorageAPIV3", "returns", "a", "new", "storage", "v3", "API", "facade", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "StorageDetails", "(", "entities", "params", ".", "Entities", ")", "(", "params", ".", "StorageDetailsResults", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "StorageDetailsResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "results", ":=", "make", "(", "[", "]", "params", ".", "StorageDetailsResult", ",", "len", "(", "entities", ".", "Entities", ")", ")", "\n", "for", "i", ",", "entity", ":=", "range", "entities", ".", "Entities", "{", "storageTag", ",", "err", ":=", "names", ".", "ParseStorageTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "storageInstance", ",", "err", ":=", "a", ".", "storageAccess", ".", "StorageInstance", "(", "storageTag", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "details", ",", "err", ":=", "createStorageDetails", "(", "a", ".", "backend", ",", "a", ".", "storageAccess", ",", "storageInstance", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", "[", "i", "]", ".", "Result", "=", "details", "\n", "}", "\n", "return", "params", ".", "StorageDetailsResults", "{", "Results", ":", "results", "}", ",", "nil", "\n", "}" ]

[ "StorageDetails", "retrieves", "and", "returns", "detailed", "information", "about", "desired", "storage", "identified", "by", "supplied", "tags", ".", "If", "specified", "storage", "cannot", "be", "retrieved", "individual", "error", "is", "returned", "instead", "of", "storage", "information", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "ListStorageDetails", "(", "filters", "params", ".", "StorageFilters", ")", "(", "params", ".", "StorageDetailsListResults", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "StorageDetailsListResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "results", ":=", "params", ".", "StorageDetailsListResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "StorageDetailsListResult", ",", "len", "(", "filters", ".", "Filters", ")", ")", ",", "}", "\n", "for", "i", ",", "filter", ":=", "range", "filters", ".", "Filters", "{", "list", ",", "err", ":=", "a", ".", "listStorageDetails", "(", "filter", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Result", "=", "list", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "ListStorageDetails", "returns", "storage", "matching", "a", "filter", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "ListPools", "(", "filters", "params", ".", "StoragePoolFilters", ",", ")", "(", "params", ".", "StoragePoolsResults", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "StoragePoolsResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "results", ":=", "params", ".", "StoragePoolsResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "StoragePoolsResult", ",", "len", "(", "filters", ".", "Filters", ")", ")", ",", "}", "\n", "for", "i", ",", "filter", ":=", "range", "filters", ".", "Filters", "{", "pools", ",", "err", ":=", "a", ".", "listPools", "(", "a", ".", "ensureStoragePoolFilter", "(", "filter", ")", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Result", "=", "pools", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "ListPools", "returns", "a", "list", "of", "pools", ".", "If", "filter", "is", "provided", "returned", "list", "only", "contains", "pools", "that", "match", "the", "filter", ".", "Pools", "can", "be", "filtered", "on", "names", "and", "provider", "types", ".", "If", "both", "names", "and", "types", "are", "provided", "as", "filter", "pools", "that", "match", "either", "are", "returned", ".", "This", "method", "lists", "union", "of", "pools", "and", "environment", "provider", "types", ".", "If", "no", "filter", "is", "provided", "all", "pools", "are", "returned", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "ListVolumes", "(", "filters", "params", ".", "VolumeFilters", ")", "(", "params", ".", "VolumeDetailsListResults", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "VolumeDetailsListResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "results", ":=", "params", ".", "VolumeDetailsListResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "VolumeDetailsListResult", ",", "len", "(", "filters", ".", "Filters", ")", ")", ",", "}", "\n", "stVolumeAccess", ":=", "a", ".", "storageAccess", ".", "VolumeAccess", "(", ")", "\n", "for", "i", ",", "filter", ":=", "range", "filters", ".", "Filters", "{", "volumes", ",", "volumeAttachments", ",", "err", ":=", "filterVolumes", "(", "stVolumeAccess", ",", "filter", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "details", ",", "err", ":=", "createVolumeDetailsList", "(", "a", ".", "backend", ",", "a", ".", "storageAccess", ",", "volumes", ",", "volumeAttachments", ",", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Result", "=", "details", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "ListVolumes", "lists", "volumes", "with", "the", "given", "filters", ".", "Each", "filter", "produces", "an", "independent", "list", "of", "volumes", "or", "an", "error", "if", "the", "filter", "is", "invalid", "or", "the", "volumes", "could", "not", "be", "listed", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "ListFilesystems", "(", "filters", "params", ".", "FilesystemFilters", ")", "(", "params", ".", "FilesystemDetailsListResults", ",", "error", ")", "{", "results", ":=", "params", ".", "FilesystemDetailsListResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "FilesystemDetailsListResult", ",", "len", "(", "filters", ".", "Filters", ")", ")", ",", "}", "\n", "if", "err", ":=", "a", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "stFileAccess", ":=", "a", ".", "storageAccess", ".", "FilesystemAccess", "(", ")", "\n", "for", "i", ",", "filter", ":=", "range", "filters", ".", "Filters", "{", "filesystems", ",", "filesystemAttachments", ",", "err", ":=", "filterFilesystems", "(", "stFileAccess", ",", "filter", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "details", ",", "err", ":=", "createFilesystemDetailsList", "(", "a", ".", "backend", ",", "a", ".", "storageAccess", ",", "filesystems", ",", "filesystemAttachments", ",", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Result", "=", "details", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "ListFilesystems", "returns", "a", "list", "of", "filesystems", "in", "the", "environment", "matching", "the", "provided", "filter", ".", "Each", "result", "describes", "a", "filesystem", "in", "detail", "including", "the", "filesystem", "s", "attachments", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "Remove", "(", "args", "params", ".", "RemoveStorage", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "return", "a", ".", "remove", "(", "args", ")", "\n", "}" ]

[ "Remove", "sets", "the", "specified", "storage", "entities", "to", "Dying", "unless", "they", "are", "already", "Dying", "or", "Dead", "such", "that", "the", "storage", "will", "eventually", "be", "removed", "from", "the", "model", ".", "If", "the", "arguments", "specify", "that", "the", "storage", "should", "be", "destroyed", "then", "the", "associated", "cloud", "storage", "will", "be", "destroyed", "first", ";", "otherwise", "it", "will", "only", "be", "released", "from", "Juju", "s", "control", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "DetachStorage", "(", "args", "params", ".", "StorageDetachmentParams", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "return", "a", ".", "internalDetach", "(", "args", ".", "StorageIds", ",", "args", ".", "Force", ",", "args", ".", "MaxWait", ")", "\n", "}" ]

[ "DetachStorage", "sets", "the", "specified", "storage", "attachments", "to", "Dying", "unless", "they", "are", "already", "Dying", "or", "Dead", ".", "Any", "associated", "persistent", "storage", "will", "remain", "alive", ".", "This", "call", "can", "be", "forced", "." ]

[ "func", "(", "a", "*", "StorageAPIv5", ")", "Detach", "(", "args", "params", ".", "StorageAttachmentIds", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "return", "a", ".", "internalDetach", "(", "args", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "Detach", "sets", "the", "specified", "storage", "attachments", "to", "Dying", "unless", "they", "are", "already", "Dying", "or", "Dead", ".", "Any", "associated", "persistent", "storage", "will", "remain", "alive", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "Attach", "(", "args", "params", ".", "StorageAttachmentIds", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanWrite", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "blockChecker", ":=", "common", ".", "NewBlockChecker", "(", "a", ".", "backend", ")", "\n", "if", "err", ":=", "blockChecker", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "attachOne", ":=", "func", "(", "arg", "params", ".", "StorageAttachmentId", ")", "error", "{", "storageTag", ",", "err", ":=", "names", ".", "ParseStorageTag", "(", "arg", ".", "StorageTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "unitTag", ",", "err", ":=", "names", ".", "ParseUnitTag", "(", "arg", ".", "UnitTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "a", ".", "attachStorage", "(", "storageTag", ",", "unitTag", ")", "\n", "}", "\n\n", "result", ":=", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "Ids", ")", ")", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Ids", "{", "result", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "attachOne", "(", "arg", ")", ")", "\n", "}", "\n", "return", "params", ".", "ErrorResults", "{", "Results", ":", "result", "}", ",", "nil", "\n", "}" ]

[ "Attach", "attaches", "existing", "storage", "instances", "to", "units", ".", "A", "CHANGE", "block", "can", "block", "this", "operation", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "Import", "(", "args", "params", ".", "BulkImportStorageParams", ")", "(", "params", ".", "ImportStorageResults", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanWrite", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ImportStorageResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "blockChecker", ":=", "common", ".", "NewBlockChecker", "(", "a", ".", "backend", ")", "\n", "if", "err", ":=", "blockChecker", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ImportStorageResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "results", ":=", "make", "(", "[", "]", "params", ".", "ImportStorageResult", ",", "len", "(", "args", ".", "Storage", ")", ")", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Storage", "{", "details", ",", "err", ":=", "a", ".", "importStorage", "(", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", "[", "i", "]", ".", "Result", "=", "details", "\n", "}", "\n", "return", "params", ".", "ImportStorageResults", "{", "Results", ":", "results", "}", ",", "nil", "\n", "}" ]

[ "Import", "imports", "existing", "storage", "into", "the", "model", ".", "A", "CHANGE", "block", "can", "block", "this", "operation", "." ]

[ "func", "(", "a", "*", "StorageAPI", ")", "RemovePool", "(", "p", "params", ".", "StoragePoolDeleteArgs", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "results", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "p", ".", "Pools", ")", ")", ",", "}", "\n", "if", "err", ":=", "a", ".", "checkCanWrite", "(", ")", ";", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "i", ",", "pool", ":=", "range", "p", ".", "Pools", "{", "err", ":=", "a", ".", "storageAccess", ".", "RemoveStoragePool", "(", "pool", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "RemovePool", "deletes", "the", "named", "pool" ]

[ "func", "(", "a", "*", "StorageAPI", ")", "UpdatePool", "(", "p", "params", ".", "StoragePoolArgs", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "results", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "p", ".", "Pools", ")", ")", ",", "}", "\n", "if", "err", ":=", "a", ".", "checkCanWrite", "(", ")", ";", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "i", ",", "pool", ":=", "range", "p", ".", "Pools", "{", "err", ":=", "a", ".", "poolManager", ".", "Replace", "(", "pool", ".", "Name", ",", "pool", ".", "Provider", ",", "pool", ".", "Attrs", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "UpdatePool", "deletes", "the", "named", "pool" ]

[ "func", "(", "a", "*", "StorageAPIv3", ")", "Destroy", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "v4Args", ":=", "params", ".", "RemoveStorage", "{", "Storage", ":", "make", "(", "[", "]", "params", ".", "RemoveStorageInstance", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Entities", "{", "v4Args", ".", "Storage", "[", "i", "]", "=", "params", ".", "RemoveStorageInstance", "{", "Tag", ":", "arg", ".", "Tag", ",", "// The v3 behaviour was to detach the storage", "// at the same time as marking the storage Dying.", "DestroyAttachments", ":", "true", ",", "DestroyStorage", ":", "true", ",", "}", "\n", "}", "\n", "return", "a", ".", "remove", "(", "v4Args", ")", "\n", "}" ]

[ "Destroy", "sets", "the", "specified", "storage", "entities", "to", "Dying", "unless", "they", "are", "already", "Dying", "or", "Dead", "." ]

[ "func", "NewHubWatcher", "(", "config", "HubWatcherConfig", ")", "(", "*", "HubWatcher", ",", "error", ")", "{", "if", "err", ":=", "config", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "watcher", ",", "_", ":=", "newHubWatcher", "(", "config", ".", "Hub", ",", "config", ".", "Clock", ",", "config", ".", "ModelUUID", ",", "config", ".", "Logger", ")", "\n", "return", "watcher", ",", "nil", "\n", "}" ]

[ "NewHubWatcher", "returns", "a", "new", "watcher", "observing", "Change", "events", "published", "to", "the", "hub", "." ]

[ "func", "(", "w", "*", "HubWatcher", ")", "Watch", "(", "collection", "string", ",", "id", "interface", "{", "}", ",", "ch", "chan", "<-", "Change", ")", "{", "if", "id", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "// We use a value of -2 to indicate that we don't know the state of the document.", "// -1 would indicate that we think the document is deleted (and won't trigger", "// a change event if the document really is deleted).", "w", ".", "sendAndWaitReq", "(", "reqWatch", "{", "key", ":", "watchKey", "{", "collection", ",", "id", "}", ",", "info", ":", "watchInfo", "{", "ch", ",", "-", "2", ",", "nil", "}", ",", "registeredCh", ":", "make", "(", "chan", "error", ")", ",", "}", ")", "\n", "}" ]

[ "Watch", "starts", "watching", "the", "given", "collection", "and", "document", "id", ".", "An", "event", "will", "be", "sent", "onto", "ch", "whenever", "a", "matching", "document", "s", "txn", "-", "revno", "field", "is", "observed", "to", "change", "after", "a", "transaction", "is", "applied", "." ]

[ "func", "(", "w", "*", "HubWatcher", ")", "UnwatchCollection", "(", "collection", "string", ",", "ch", "chan", "<-", "Change", ")", "{", "w", ".", "sendReq", "(", "reqUnwatch", "{", "watchKey", "{", "collection", ",", "nil", "}", ",", "ch", "}", ")", "\n", "}" ]

[ "UnwatchCollection", "stops", "watching", "the", "given", "collection", "via", "ch", "." ]

[ "func", "(", "w", "*", "HubWatcher", ")", "Report", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "stats", ":=", "w", ".", "Stats", "(", ")", "\n", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "stats", ".", "WatchCount", ",", "\"", "\"", ":", "stats", ".", "WatchKeyCount", ",", "\"", "\"", ":", "stats", ".", "SyncQueueCap", ",", "\"", "\"", ":", "stats", ".", "SyncQueueLen", ",", "\"", "\"", ":", "stats", ".", "SyncLastLen", ",", "\"", "\"", ":", "stats", ".", "SyncAvgLen", ",", "\"", "\"", ":", "stats", ".", "SyncMaxLen", ",", "\"", "\"", ":", "stats", ".", "SyncEventDocCount", ",", "\"", "\"", ":", "stats", ".", "SyncEventCollCount", ",", "\"", "\"", ":", "stats", ".", "RequestCount", ",", "\"", "\"", ":", "stats", ".", "ChangeCount", ",", "}", "\n", "}" ]

[ "Report", "conforms", "to", "the", "worker", ".", "Runner", ".", "Report", "interface", "for", "returning", "information", "about", "the", "active", "worker", "." ]

[ "func", "(", "w", "*", "HubWatcher", ")", "queueChange", "(", "change", "Change", ")", "{", "w", ".", "changeCount", "++", "\n", "w", ".", "logger", ".", "Tracef", "(", "\"", "\"", ",", "w", ",", "change", ")", "\n", "key", ":=", "watchKey", "{", "change", ".", "C", ",", "change", ".", "Id", "}", "\n", "revno", ":=", "change", ".", "Revno", "\n\n", "// Queue notifications for per-collection watches.", "for", "_", ",", "info", ":=", "range", "w", ".", "watches", "[", "watchKey", "{", "change", ".", "C", ",", "nil", "}", "]", "{", "if", "info", ".", "filter", "!=", "nil", "&&", "!", "info", ".", "filter", "(", "change", ".", "Id", ")", "{", "continue", "\n", "}", "\n", "evt", ":=", "event", "{", "ch", ":", "info", ".", "ch", ",", "key", ":", "key", ",", "revno", ":", "revno", ",", "}", "\n", "w", ".", "syncEvents", "=", "append", "(", "w", ".", "syncEvents", ",", "evt", ")", "\n", "w", ".", "syncEventCollectionCount", "++", "\n", "w", ".", "logger", ".", "Tracef", "(", "\"", "\"", ",", "w", ",", "change", ".", "C", ",", "info", ".", "ch", ",", "len", "(", "w", ".", "syncEvents", ")", ",", "cap", "(", "w", ".", "syncEvents", ")", ")", "\n", "}", "\n\n", "// Queue notifications for per-document watches.", "infos", ":=", "w", ".", "watches", "[", "key", "]", "\n", "for", "i", ",", "info", ":=", "range", "infos", "{", "if", "revno", ">", "info", ".", "revno", "||", "revno", "<", "0", "&&", "info", ".", "revno", ">=", "0", "{", "infos", "[", "i", "]", ".", "revno", "=", "revno", "\n", "evt", ":=", "event", "{", "ch", ":", "info", ".", "ch", ",", "key", ":", "key", ",", "revno", ":", "revno", ",", "}", "\n", "w", ".", "syncEvents", "=", "append", "(", "w", ".", "syncEvents", ",", "evt", ")", "\n", "w", ".", "syncEventDocCount", "++", "\n", "w", ".", "logger", ".", "Tracef", "(", "\"", "\"", ",", "w", ",", "key", ",", "info", ".", "ch", ",", "len", "(", "w", ".", "syncEvents", ")", ",", "cap", "(", "w", ".", "syncEvents", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "queueChange", "queues", "up", "the", "change", "for", "the", "registered", "watchers", "." ]

[ "func", "(", "p", "PrepareParams", ")", "Validate", "(", ")", "error", "{", "if", "err", ":=", "p", ".", "ControllerConfig", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "p", ".", "ControllerName", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "p", ".", "Cloud", ".", "Name", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "p", ".", "AdminSecret", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "the", "PrepareParams", "." ]

[ "func", "PrepareController", "(", "isCAASController", "bool", ",", "ctx", "environs", ".", "BootstrapContext", ",", "store", "jujuclient", ".", "ClientStore", ",", "args", "PrepareParams", ",", ")", "(", "environs", ".", "BootstrapEnviron", ",", "error", ")", "{", "if", "err", ":=", "args", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "_", ",", "err", ":=", "store", ".", "ControllerByName", "(", "args", ".", "ControllerName", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", ",", "errors", ".", "AlreadyExistsf", "(", "\"", "\"", ",", "args", ".", "ControllerName", ")", "\n", "}", "else", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "args", ".", "ControllerName", ")", "\n", "}", "\n\n", "cloudType", ",", "ok", ":=", "args", ".", "ModelConfig", "[", "\"", "\"", "]", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "p", ",", "err", ":=", "environs", ".", "Provider", "(", "cloudType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "cfg", ",", "details", ",", "err", ":=", "prepare", "(", "ctx", ",", "p", ",", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "do", ":=", "func", "(", ")", "error", "{", "if", "err", ":=", "decorateAndWriteInfo", "(", "store", ",", "details", ",", "args", ".", "ControllerName", ",", "cfg", ".", "Name", "(", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "args", ".", "ControllerName", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "var", "env", "environs", ".", "BootstrapEnviron", "\n", "openParams", ":=", "environs", ".", "OpenParams", "{", "ControllerUUID", ":", "args", ".", "ControllerConfig", ".", "ControllerUUID", "(", ")", ",", "Cloud", ":", "args", ".", "Cloud", ",", "Config", ":", "cfg", ",", "}", "\n", "if", "isCAASController", "{", "details", ".", "ModelType", "=", "model", ".", "CAAS", "\n", "env", ",", "err", "=", "caas", ".", "Open", "(", "p", ",", "openParams", ")", "\n", "}", "else", "{", "details", ".", "ModelType", "=", "model", ".", "IAAS", "\n", "env", ",", "err", "=", "environs", ".", "Open", "(", "p", ",", "openParams", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "env", ".", "PrepareForBootstrap", "(", "ctx", ",", "args", ".", "ControllerName", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "do", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "env", ",", "nil", "\n", "}" ]

[ "PrepareController", "prepares", "a", "new", "controller", "based", "on", "the", "provided", "configuration", ".", "It", "is", "an", "error", "to", "prepare", "a", "controller", "if", "there", "already", "exists", "an", "entry", "in", "the", "client", "store", "with", "the", "same", "name", ".", "Upon", "success", "Prepare", "will", "update", "the", "ClientStore", "with", "the", "details", "of", "the", "controller", "admin", "account", "and", "admin", "model", "." ]

[ "func", "decorateAndWriteInfo", "(", "store", "jujuclient", ".", "ClientStore", ",", "details", "prepareDetails", ",", "controllerName", ",", "modelName", "string", ",", ")", "error", "{", "qualifiedModelName", ":=", "jujuclient", ".", "JoinOwnerModelName", "(", "names", ".", "NewUserTag", "(", "details", ".", "AccountDetails", ".", "User", ")", ",", "modelName", ",", ")", "\n", "if", "err", ":=", "store", ".", "AddController", "(", "controllerName", ",", "details", ".", "ControllerDetails", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "store", ".", "UpdateBootstrapConfig", "(", "controllerName", ",", "details", ".", "BootstrapConfig", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "store", ".", "UpdateAccount", "(", "controllerName", ",", "details", ".", "AccountDetails", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "store", ".", "UpdateModel", "(", "controllerName", ",", "qualifiedModelName", ",", "details", ".", "ModelDetails", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "store", ".", "SetCurrentModel", "(", "controllerName", ",", "qualifiedModelName", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "decorateAndWriteInfo", "decorates", "the", "info", "struct", "with", "information", "from", "the", "given", "cfg", "and", "the", "writes", "that", "out", "to", "the", "filesystem", "." ]

[ "func", "(", "s", "*", "HTTPSender", ")", "Send", "(", "metrics", "[", "]", "*", "wireformat", ".", "MetricBatch", ")", "(", "*", "wireformat", ".", "Response", ",", "error", ")", "{", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "metrics", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "r", ":=", "bytes", ".", "NewBuffer", "(", "b", ")", "\n", "client", ":=", "&", "http", ".", "Client", "{", "}", "\n", "resp", ",", "err", ":=", "client", ".", "Post", "(", "s", ".", "url", ",", "\"", "\"", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "resp", ".", "StatusCode", "!=", "http", ".", "StatusOK", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "resp", ".", "StatusCode", ")", "\n", "}", "\n\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "respReader", ":=", "json", ".", "NewDecoder", "(", "resp", ".", "Body", ")", "\n", "metricsResponse", ":=", "wireformat", ".", "Response", "{", "}", "\n", "err", "=", "respReader", ".", "Decode", "(", "&", "metricsResponse", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "metricsResponse", ",", "nil", "\n", "}" ]

[ "Send", "sends", "the", "given", "metrics", "to", "the", "collector", "service", "." ]

[ "func", "HasPermission", "(", "accessGetter", "userAccessFunc", ",", "utag", "names", ".", "Tag", ",", "requestedPermission", "permission", ".", "Access", ",", "target", "names", ".", "Tag", ",", ")", "(", "bool", ",", "error", ")", "{", "var", "validate", "func", "(", "permission", ".", "Access", ")", "error", "\n", "switch", "target", ".", "Kind", "(", ")", "{", "case", "names", ".", "ControllerTagKind", ":", "validate", "=", "permission", ".", "ValidateControllerAccess", "\n", "case", "names", ".", "ModelTagKind", ":", "validate", "=", "permission", ".", "ValidateModelAccess", "\n", "case", "names", ".", "ApplicationOfferTagKind", ":", "validate", "=", "permission", ".", "ValidateOfferAccess", "\n", "case", "names", ".", "CloudTagKind", ":", "validate", "=", "permission", ".", "ValidateCloudAccess", "\n", "default", ":", "return", "false", ",", "nil", "\n", "}", "\n", "if", "err", ":=", "validate", "(", "requestedPermission", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "userTag", ",", "ok", ":=", "utag", ".", "(", "names", ".", "UserTag", ")", "\n", "if", "!", "ok", "{", "// lets not reveal more than is strictly necessary", "return", "false", ",", "nil", "\n", "}", "\n\n", "userAccess", ",", "err", ":=", "GetPermission", "(", "accessGetter", ",", "userTag", ",", "target", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "false", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "target", ".", "Kind", "(", ")", ")", "\n", "}", "\n", "// returning this kind of information would be too much information to reveal too.", "if", "errors", ".", "IsNotFound", "(", "err", ")", "||", "userAccess", "==", "permission", ".", "NoAccess", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "modelPermission", ":=", "userAccess", ".", "EqualOrGreaterModelAccessThan", "(", "requestedPermission", ")", "&&", "target", ".", "Kind", "(", ")", "==", "names", ".", "ModelTagKind", "\n", "controllerPermission", ":=", "userAccess", ".", "EqualOrGreaterControllerAccessThan", "(", "requestedPermission", ")", "&&", "target", ".", "Kind", "(", ")", "==", "names", ".", "ControllerTagKind", "\n", "offerPermission", ":=", "userAccess", ".", "EqualOrGreaterOfferAccessThan", "(", "requestedPermission", ")", "&&", "target", ".", "Kind", "(", ")", "==", "names", ".", "ApplicationOfferTagKind", "\n", "cloudPermission", ":=", "userAccess", ".", "EqualOrGreaterCloudAccessThan", "(", "requestedPermission", ")", "&&", "target", ".", "Kind", "(", ")", "==", "names", ".", "CloudTagKind", "\n", "if", "!", "controllerPermission", "&&", "!", "modelPermission", "&&", "!", "offerPermission", "&&", "!", "cloudPermission", "{", "return", "false", ",", "nil", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "HasPermission", "returns", "true", "if", "the", "specified", "user", "has", "the", "specified", "permission", "on", "target", "." ]

[ "func", "GetPermission", "(", "accessGetter", "userAccessFunc", ",", "userTag", "names", ".", "UserTag", ",", "target", "names", ".", "Tag", ")", "(", "permission", ".", "Access", ",", "error", ")", "{", "userAccess", ",", "err", ":=", "accessGetter", "(", "userTag", ",", "target", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "permission", ".", "NoAccess", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "target", ".", "Kind", "(", ")", ")", "\n", "}", "\n", "// there is a special case for external users, a group called everyone@external", "if", "!", "userTag", ".", "IsLocal", "(", ")", "{", "// TODO(perrito666) remove the following section about everyone group", "// when groups are implemented.", "everyoneTag", ":=", "names", ".", "NewUserTag", "(", "EveryoneTagName", ")", "\n", "everyoneAccess", ",", "err", ":=", "accessGetter", "(", "everyoneTag", ",", "target", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "permission", ".", "NoAccess", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "userAccess", "==", "permission", ".", "NoAccess", "&&", "everyoneAccess", "!=", "permission", ".", "NoAccess", "{", "userAccess", "=", "everyoneAccess", "\n", "}", "\n", "if", "everyoneAccess", ".", "EqualOrGreaterControllerAccessThan", "(", "userAccess", ")", "{", "userAccess", "=", "everyoneAccess", "\n", "}", "\n", "}", "\n", "return", "userAccess", ",", "nil", "\n", "}" ]

[ "GetPermission", "returns", "the", "permission", "a", "user", "has", "on", "the", "specified", "target", "." ]

[ "func", "HasModelAdmin", "(", "authorizer", "facade", ".", "Authorizer", ",", "user", "names", ".", "UserTag", ",", "controllerTag", "names", ".", "ControllerTag", ",", "model", "Model", ",", ")", "(", "bool", ",", "error", ")", "{", "// superusers have admin for all models.", "if", "isSuperUser", ",", "err", ":=", "authorizer", ".", "HasPermission", "(", "permission", ".", "SuperuserAccess", ",", "controllerTag", ")", ";", "err", "!=", "nil", "||", "isSuperUser", "{", "return", "isSuperUser", ",", "err", "\n", "}", "\n", "return", "authorizer", ".", "HasPermission", "(", "permission", ".", "AdminAccess", ",", "model", ".", "ModelTag", "(", ")", ")", "\n", "}" ]

[ "HasModelAdmin", "reports", "whether", "or", "not", "a", "user", "has", "admin", "access", "to", "the", "specified", "model", ".", "A", "user", "has", "model", "access", "if", "they", "are", "a", "controller", "superuser", "or", "if", "they", "have", "been", "explicitly", "granted", "admin", "access", "to", "the", "model", "." ]

[ "func", "(", "st", "resourceState", ")", "ListResources", "(", "applicationID", "string", ")", "(", "resource", ".", "ApplicationResources", ",", "error", ")", "{", "resources", ",", "err", ":=", "st", ".", "persist", ".", "ListResources", "(", "applicationID", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", ":=", "st", ".", "raw", ".", "VerifyApplication", "(", "applicationID", ")", ";", "err", "!=", "nil", "{", "return", "resource", ".", "ApplicationResources", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "resource", ".", "ApplicationResources", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "unitIDs", ",", "err", ":=", "st", ".", "raw", ".", "Units", "(", "applicationID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "resource", ".", "ApplicationResources", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "unitID", ":=", "range", "unitIDs", "{", "found", ":=", "false", "\n", "for", "_", ",", "unitRes", ":=", "range", "resources", ".", "UnitResources", "{", "if", "unitID", ".", "String", "(", ")", "==", "unitRes", ".", "Tag", ".", "String", "(", ")", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "unitRes", ":=", "resource", ".", "UnitResources", "{", "Tag", ":", "unitID", ",", "}", "\n", "resources", ".", "UnitResources", "=", "append", "(", "resources", ".", "UnitResources", ",", "unitRes", ")", "\n", "}", "\n", "}", "\n\n", "return", "resources", ",", "nil", "\n", "}" ]

[ "ListResources", "returns", "the", "resource", "data", "for", "the", "given", "application", "ID", "." ]