Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "GetOfferStatusChange", "(", "st", "offerGetter", ",", "offerUUID", "string", ")", "(", "*", "params", ".", "OfferStatusChange", ",", "error", ")", "{", "offer", ",", "err", ":=", "st", ".", "ApplicationOfferForUUID", "(", "offerUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// TODO(wallyworld) - for now, offer status is just the application status", "app", ",", "err", ":=", "st", ".", "Application", "(", "offer", ".", "ApplicationName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "status", ",", "err", ":=", "app", ".", "Status", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "params", ".", "OfferStatusChange", "{", "OfferName", ":", "offer", ".", "OfferName", ",", "Status", ":", "params", ".", "EntityStatus", "{", "Status", ":", "status", ".", "Status", ",", "Info", ":", "status", ".", "Message", ",", "Data", ":", "status", ".", "Data", ",", "Since", ":", "status", ".", "Since", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "GetOfferStatusChange", "returns", "a", "status", "change", "struct", "for", "a", "specified", "offer", "name", "." ]

[ "func", "(", "c", "*", "Client", ")", "AddUser", "(", "username", ",", "displayName", ",", "password", "string", ",", ")", "(", "_", "names", ".", "UserTag", ",", "secretKey", "[", "]", "byte", ",", "_", "error", ")", "{", "if", "!", "names", ".", "IsValidUser", "(", "username", ")", "{", "return", "names", ".", "UserTag", "{", "}", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "username", ")", "\n", "}", "\n\n", "userArgs", ":=", "params", ".", "AddUsers", "{", "Users", ":", "[", "]", "params", ".", "AddUser", "{", "{", "Username", ":", "username", ",", "DisplayName", ":", "displayName", ",", "Password", ":", "password", ",", "}", "}", ",", "}", "\n", "var", "results", "params", ".", "AddUserResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "userArgs", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "names", ".", "UserTag", "{", "}", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "count", ":=", "len", "(", "results", ".", "Results", ")", ";", "count", "!=", "1", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "results", ")", "\n", "return", "names", ".", "UserTag", "{", "}", ",", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "count", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "names", ".", "UserTag", "{", "}", ",", "nil", ",", "errors", ".", "Trace", "(", "result", ".", "Error", ")", "\n", "}", "\n", "tag", ",", "err", ":=", "names", ".", "ParseUserTag", "(", "result", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "names", ".", "UserTag", "{", "}", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "tag", ",", "result", ".", "SecretKey", ",", "nil", "\n", "}" ]

[ "AddUser", "creates", "a", "new", "local", "user", "in", "the", "controller", "sharing", "with", "that", "user", "any", "specified", "models", "." ]

[ "func", "(", "c", "*", "Client", ")", "UserInfo", "(", "usernames", "[", "]", "string", ",", "all", "IncludeDisabled", ")", "(", "[", "]", "params", ".", "UserInfo", ",", "error", ")", "{", "var", "results", "params", ".", "UserInfoResults", "\n", "var", "entities", "[", "]", "params", ".", "Entity", "\n", "for", "_", ",", "username", ":=", "range", "usernames", "{", "if", "!", "names", ".", "IsValidUser", "(", "username", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "username", ")", "\n", "}", "\n", "tag", ":=", "names", ".", "NewUserTag", "(", "username", ")", "\n", "entities", "=", "append", "(", "entities", ",", "params", ".", "Entity", "{", "Tag", ":", "tag", ".", "String", "(", ")", "}", ")", "\n", "}", "\n", "args", ":=", "params", ".", "UserInfoRequest", "{", "Entities", ":", "entities", ",", "IncludeDisabled", ":", "bool", "(", "all", ")", ",", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Only need to look for errors if users were explicitly specified, because", "// if we didn't ask for any, we should get all, and we shouldn't get any", "// errors for listing all. We care here because we index into the users", "// slice.", "if", "len", "(", "results", ".", "Results", ")", "==", "len", "(", "usernames", ")", "{", "var", "errorStrings", "[", "]", "string", "\n", "for", "i", ",", "result", ":=", "range", "results", ".", "Results", "{", "if", "result", ".", "Error", "!=", "nil", "{", "annotated", ":=", "errors", ".", "Annotate", "(", "result", ".", "Error", ",", "usernames", "[", "i", "]", ")", "\n", "errorStrings", "=", "append", "(", "errorStrings", ",", "annotated", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "// TODO(wallyworld) - we should return these errors to the caller so that any", "// users which are successfully found can be handled.", "if", "len", "(", "errorStrings", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "strings", ".", "Join", "(", "errorStrings", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n", "info", ":=", "[", "]", "params", ".", "UserInfo", "{", "}", "\n", "for", "i", ",", "result", ":=", "range", "results", ".", "Results", "{", "if", "result", ".", "Result", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "i", ")", "\n", "}", "\n", "info", "=", "append", "(", "info", ",", "*", "result", ".", "Result", ")", "\n", "}", "\n", "return", "info", ",", "nil", "\n", "}" ]

[ "UserInfo", "returns", "information", "about", "the", "specified", "users", ".", "If", "no", "users", "are", "specified", "the", "call", "should", "return", "all", "users", ".", "If", "includeDisabled", "is", "set", "to", "ActiveUsers", "only", "enabled", "users", "are", "returned", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetPassword", "(", "username", ",", "password", "string", ")", "error", "{", "if", "!", "names", ".", "IsValidUser", "(", "username", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "username", ")", "\n", "}", "\n", "tag", ":=", "names", ".", "NewUserTag", "(", "username", ")", "\n", "args", ":=", "params", ".", "EntityPasswords", "{", "Changes", ":", "[", "]", "params", ".", "EntityPassword", "{", "{", "Tag", ":", "tag", ".", "String", "(", ")", ",", "Password", ":", "password", "}", "}", ",", "}", "\n", "var", "results", "params", ".", "ErrorResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "results", ".", "OneError", "(", ")", "\n", "}" ]

[ "SetPassword", "changes", "the", "password", "for", "the", "specified", "user", "." ]

[ "func", "(", "c", "*", "Client", ")", "ResetPassword", "(", "username", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "!", "names", ".", "IsValidUser", "(", "username", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "username", ")", "\n", "}", "\n\n", "in", ":=", "params", ".", "Entities", "{", "Entities", ":", "[", "]", "params", ".", "Entity", "{", "{", "Tag", ":", "names", ".", "NewUserTag", "(", "username", ")", ".", "String", "(", ")", ",", "}", "}", ",", "}", "\n", "var", "out", "params", ".", "AddUserResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "in", ",", "&", "out", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "count", ":=", "len", "(", "out", ".", "Results", ")", ";", "count", "!=", "1", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "out", ")", "\n", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "count", ")", "\n", "}", "\n", "result", ":=", "out", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "result", ".", "Error", ")", "\n", "}", "\n", "return", "result", ".", "SecretKey", ",", "nil", "\n", "}" ]

[ "ResetPassword", "resets", "password", "for", "the", "specified", "user", "." ]

[ "func", "New", "(", "source", "ConfigSource", ",", "initial", "auditlog", ".", "Config", ",", "logFactory", "AuditLogFactory", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "u", ":=", "&", "updater", "{", "source", ":", "source", ",", "current", ":", "initial", ",", "logFactory", ":", "logFactory", ",", "}", "\n", "err", ":=", "catacomb", ".", "Invoke", "(", "catacomb", ".", "Plan", "{", "Site", ":", "&", "u", ".", "catacomb", ",", "Work", ":", "u", ".", "loop", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "u", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "worker", "that", "will", "keep", "an", "up", "-", "to", "-", "date", "audit", "log", "config", "." ]

[ "func", "(", "u", "*", "updater", ")", "CurrentConfig", "(", ")", "auditlog", ".", "Config", "{", "u", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "u", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "u", ".", "current", "\n", "}" ]

[ "CurrentConfig", "returns", "the", "updater", "s", "up", "-", "to", "-", "date", "audit", "config", "." ]

[ "func", "(", "ctx", "*", "leadershipContext", ")", "IsLeader", "(", ")", "(", "bool", ",", "error", ")", "{", "// This doesn't technically need an error return, but that feels like a", "// happy accident of the current implementation and not a reason to change", "// the interface we're implementing.", "err", ":=", "ctx", ".", "ensureLeader", "(", ")", "\n", "switch", "err", "{", "case", "nil", ":", "return", "true", ",", "nil", "\n", "case", "errIsMinion", ":", "return", "false", ",", "nil", "\n", "}", "\n", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "IsLeader", "is", "part", "of", "the", "hooks", ".", "Context", "interface", "." ]

[ "func", "(", "ctx", "*", "leadershipContext", ")", "WriteLeaderSettings", "(", "settings", "map", "[", "string", "]", "string", ")", "error", "{", "// This may trigger a lease refresh; it would be desirable to use a less", "// eager approach here, but we're working around a race described in", "// `apiserver/leadership.LeadershipSettingsAccessor.Merge`, and as of", "// 2015-02-19 it's better to stay eager.", "err", ":=", "ctx", ".", "ensureLeader", "(", ")", "\n", "if", "err", "==", "errIsMinion", "{", "logger", ".", "Warningf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "err", "==", "nil", "{", "// Clear local settings; if we need them again we should use the values", "// as merged by the server. But we don't need to get them again right now;", "// the charm may not need to ask again before the hook finishes.", "ctx", ".", "settings", "=", "nil", "\n", "err", "=", "ctx", ".", "accessor", ".", "Merge", "(", "ctx", ".", "applicationName", ",", "ctx", ".", "unitName", ",", "settings", ")", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}" ]

[ "WriteLeaderSettings", "is", "part", "of", "the", "hooks", ".", "Context", "interface", "." ]

[ "func", "(", "ctx", "*", "leadershipContext", ")", "LeaderSettings", "(", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "if", "ctx", ".", "settings", "==", "nil", "{", "var", "err", "error", "\n", "ctx", ".", "settings", ",", "err", "=", "ctx", ".", "accessor", ".", "Read", "(", "ctx", ".", "applicationName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "result", ":=", "map", "[", "string", "]", "string", "{", "}", "\n", "for", "key", ",", "value", ":=", "range", "ctx", ".", "settings", "{", "result", "[", "key", "]", "=", "value", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "LeaderSettings", "is", "part", "of", "the", "hooks", ".", "Context", "interface", "." ]

[ "func", "(", "src", "List", ")", "String", "(", ")", "string", "{", "names", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "src", ")", ")", "\n", "for", "i", ",", "tools", ":=", "range", "src", "{", "names", "[", "i", "]", "=", "tools", ".", "Version", ".", "String", "(", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "names", ",", "\"", "\"", ")", "\n", "}" ]

[ "String", "returns", "the", "versions", "of", "the", "tools", "in", "src", "separated", "by", "semicolons", "." ]

[ "func", "(", "src", "List", ")", "AllSeries", "(", ")", "[", "]", "string", "{", "return", "src", ".", "collect", "(", "func", "(", "tools", "*", "Tools", ")", "string", "{", "return", "tools", ".", "Version", ".", "Series", "\n", "}", ")", "\n", "}" ]

[ "AllSeries", "returns", "all", "series", "for", "which", "some", "tools", "in", "src", "were", "built", "." ]

[ "func", "(", "src", "List", ")", "OneSeries", "(", ")", "string", "{", "series", ":=", "src", ".", "AllSeries", "(", ")", "\n", "if", "len", "(", "series", ")", "!=", "1", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "series", ")", ")", "\n", "}", "\n", "return", "series", "[", "0", "]", "\n", "}" ]

[ "OneSeries", "returns", "the", "single", "series", "for", "which", "all", "tools", "in", "src", "were", "built", "." ]

[ "func", "(", "src", "List", ")", "Arches", "(", ")", "[", "]", "string", "{", "return", "src", ".", "collect", "(", "func", "(", "tools", "*", "Tools", ")", "string", "{", "return", "tools", ".", "Version", ".", "Arch", "\n", "}", ")", "\n", "}" ]

[ "Arches", "returns", "all", "architectures", "for", "which", "some", "tools", "in", "src", "were", "built", "." ]

[ "func", "(", "src", "List", ")", "collect", "(", "f", "func", "(", "*", "Tools", ")", "string", ")", "[", "]", "string", "{", "seen", ":=", "make", "(", "set", ".", "Strings", ")", "\n", "for", "_", ",", "tools", ":=", "range", "src", "{", "seen", ".", "Add", "(", "f", "(", "tools", ")", ")", "\n", "}", "\n", "return", "seen", ".", "SortedValues", "(", ")", "\n", "}" ]

[ "collect", "calls", "f", "on", "all", "values", "in", "src", "and", "returns", "an", "alphabetically", "ordered", "list", "of", "the", "returned", "results", "without", "duplicates", "." ]

[ "func", "(", "src", "List", ")", "URLs", "(", ")", "map", "[", "version", ".", "Binary", "]", "[", "]", "string", "{", "result", ":=", "map", "[", "version", ".", "Binary", "]", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "tools", ":=", "range", "src", "{", "result", "[", "tools", ".", "Version", "]", "=", "append", "(", "result", "[", "tools", ".", "Version", "]", ",", "tools", ".", "URL", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "URLs", "returns", "download", "URLs", "for", "the", "tools", "in", "src", "keyed", "by", "binary", "version", ".", "Each", "version", "can", "have", "more", "than", "one", "URL", "." ]

[ "func", "(", "src", "List", ")", "Newest", "(", ")", "(", "version", ".", "Number", ",", "List", ")", "{", "var", "result", "List", "\n", "var", "best", "version", ".", "Number", "\n", "for", "_", ",", "tools", ":=", "range", "src", "{", "if", "best", ".", "Compare", "(", "tools", ".", "Version", ".", "Number", ")", "<", "0", "{", "// Found new best number; reset result list.", "best", "=", "tools", ".", "Version", ".", "Number", "\n", "result", "=", "append", "(", "result", "[", ":", "0", "]", ",", "tools", ")", "\n", "}", "else", "if", "tools", ".", "Version", ".", "Number", "==", "best", "{", "result", "=", "append", "(", "result", ",", "tools", ")", "\n", "}", "\n", "}", "\n", "return", "best", ",", "result", "\n", "}" ]

[ "Newest", "returns", "the", "greatest", "version", "in", "src", "and", "the", "tools", "with", "that", "version", "." ]

[ "func", "(", "src", "Versions", ")", "Newest", "(", ")", "(", "version", ".", "Number", ",", "Versions", ")", "{", "var", "result", "Versions", "\n", "var", "best", "version", ".", "Number", "\n", "for", "_", ",", "agent", ":=", "range", "src", "{", "if", "best", ".", "Compare", "(", "agent", ".", "AgentVersion", "(", ")", ")", "<", "0", "{", "// Found new best number; reset result list.", "best", "=", "agent", ".", "AgentVersion", "(", ")", "\n", "result", "=", "append", "(", "result", "[", ":", "0", "]", ",", "agent", ")", "\n", "}", "else", "if", "agent", ".", "AgentVersion", "(", ")", "==", "best", "{", "result", "=", "append", "(", "result", ",", "agent", ")", "\n", "}", "\n", "}", "\n", "return", "best", ",", "result", "\n", "}" ]

[ "Newest", "returns", "the", "greatest", "version", "in", "src", "and", "the", "instances", "with", "that", "version", "." ]

[ "func", "(", "src", "Versions", ")", "NewestCompatible", "(", "base", "version", ".", "Number", ")", "(", "newest", "version", ".", "Number", ",", "found", "bool", ")", "{", "newest", "=", "base", "\n", "found", "=", "false", "\n", "for", "_", ",", "agent", ":=", "range", "src", "{", "toolVersion", ":=", "agent", ".", "AgentVersion", "(", ")", "\n", "if", "newest", "==", "toolVersion", "{", "found", "=", "true", "\n", "}", "else", "if", "newest", ".", "Compare", "(", "toolVersion", ")", "<", "0", "&&", "toolVersion", ".", "Major", "==", "newest", ".", "Major", "&&", "toolVersion", ".", "Minor", "==", "newest", ".", "Minor", "{", "newest", "=", "toolVersion", "\n", "found", "=", "true", "\n", "}", "\n", "}", "\n", "return", "newest", ",", "found", "\n", "}" ]

[ "NewestCompatible", "returns", "the", "most", "recent", "version", "compatible", "with", "base", "i", ".", "e", ".", "with", "the", "same", "major", "and", "minor", "numbers", "and", "greater", "or", "equal", "patch", "and", "build", "numbers", "." ]

[ "func", "(", "src", "List", ")", "Exclude", "(", "excluded", "List", ")", "List", "{", "ignore", ":=", "make", "(", "map", "[", "version", ".", "Binary", "]", "bool", ",", "len", "(", "excluded", ")", ")", "\n", "for", "_", ",", "tool", ":=", "range", "excluded", "{", "ignore", "[", "tool", ".", "Version", "]", "=", "true", "\n", "}", "\n", "var", "result", "List", "\n", "for", "_", ",", "tool", ":=", "range", "src", "{", "if", "!", "ignore", "[", "tool", ".", "Version", "]", "{", "result", "=", "append", "(", "result", ",", "tool", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Exclude", "returns", "the", "tools", "in", "src", "that", "are", "not", "in", "excluded", "." ]

[ "func", "(", "src", "List", ")", "Match", "(", "f", "Filter", ")", "(", "List", ",", "error", ")", "{", "var", "result", "List", "\n", "for", "_", ",", "tools", ":=", "range", "src", "{", "if", "f", ".", "match", "(", "tools", ")", "{", "result", "=", "append", "(", "result", ",", "tools", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "result", ")", "==", "0", "{", "return", "nil", ",", "ErrNoMatches", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Match", "returns", "a", "List", "derived", "from", "src", "containing", "only", "those", "tools", "that", "match", "the", "supplied", "Filter", ".", "If", "no", "tools", "match", "it", "returns", "ErrNoMatches", "." ]

[ "func", "(", "src", "Versions", ")", "Match", "(", "f", "Filter", ")", "(", "Versions", ",", "error", ")", "{", "var", "result", "Versions", "\n", "for", "_", ",", "agent", ":=", "range", "src", "{", "if", "f", ".", "match", "(", "agent", ")", "{", "result", "=", "append", "(", "result", ",", "agent", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "result", ")", "==", "0", "{", "return", "nil", ",", "ErrNoMatches", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Match", "returns", "a", "List", "derived", "from", "src", "containing", "only", "those", "instances", "that", "match", "the", "supplied", "Filter", ".", "If", "no", "tools", "match", "it", "returns", "ErrNoMatches", "." ]

[ "func", "(", "f", "Filter", ")", "match", "(", "agent", "HasVersion", ")", "bool", "{", "if", "f", ".", "Number", "!=", "version", ".", "Zero", "&&", "agent", ".", "AgentVersion", "(", ")", "!=", "f", ".", "Number", "{", "return", "false", "\n", "}", "\n", "tools", ",", "ok", ":=", "agent", ".", "(", "*", "Tools", ")", "\n", "if", "!", "ok", "{", "return", "true", "\n", "}", "\n", "if", "f", ".", "Series", "!=", "\"", "\"", "&&", "tools", ".", "Version", ".", "Series", "!=", "f", ".", "Series", "{", "return", "false", "\n", "}", "\n", "if", "f", ".", "Arch", "!=", "\"", "\"", "&&", "tools", ".", "Version", ".", "Arch", "!=", "f", ".", "Arch", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "match", "returns", "true", "if", "the", "supplied", "tools", "match", "f", "." ]

[ "func", "(", "c", "Config", ")", "Validate", "(", ")", "error", "{", "if", "c", ".", "AgentName", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "Clock", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "Logger", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "LogFilename", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "ensures", "that", "all", "the", "required", "config", "values", "are", "set", "." ]

[ "func", "New", "(", "config", "Config", ")", "(", "*", "lock", ",", "error", ")", "{", "if", "err", ":=", "config", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "lock", ":=", "&", "lock", "{", "agent", ":", "config", ".", "AgentName", ",", "clock", ":", "config", ".", "Clock", ",", "logger", ":", "config", ".", "Logger", ",", "logFilename", ":", "config", ".", "LogFilename", ",", "acquire", ":", "mutex", ".", "Acquire", ",", "spec", ":", "mutex", ".", "Spec", "{", "Name", ":", "\"", "\"", ",", "Clock", ":", "config", ".", "Clock", ",", "Delay", ":", "250", "*", "time", ".", "Millisecond", ",", "// Cancel is added in Acquire.", "}", ",", "waiting", ":", "make", "(", "map", "[", "int", "]", "*", "info", ")", ",", "history", ":", "deque", ".", "NewWithMaxLen", "(", "1000", ")", ",", "}", "\n", "lock", ".", "setStartMessage", "(", ")", "\n", "return", "lock", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "new", "machine", "lock", "." ]

[ "func", "(", "s", "Spec", ")", "Validate", "(", ")", "error", "{", "if", "s", ".", "Cancel", "==", "nil", "{", "if", "!", "s", ".", "NoCancel", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "s", ".", "Worker", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "ensures", "that", "a", "Cancel", "channel", "and", "a", "Worker", "name", "are", "defined", "." ]

[ "func", "(", "c", "*", "lock", ")", "Acquire", "(", "spec", "Spec", ")", "(", "func", "(", ")", ",", "error", ")", "{", "if", "err", ":=", "spec", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "current", ":=", "&", "info", "{", "worker", ":", "spec", ".", "Worker", ",", "comment", ":", "spec", ".", "Comment", ",", "stack", ":", "string", "(", "debug", ".", "Stack", "(", ")", ")", ",", "requested", ":", "c", ".", "clock", ".", "Now", "(", ")", ",", "}", "\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n\n", "id", ":=", "c", ".", "next", "\n", "c", ".", "next", "++", "\n", "c", ".", "waiting", "[", "id", "]", "=", "current", "\n\n", "mSpec", ":=", "c", ".", "spec", "\n", "mSpec", ".", "Cancel", "=", "spec", ".", "Cancel", "\n\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "c", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "spec", ".", "Worker", ",", "spec", ".", "Comment", ")", "\n", "releaser", ",", "err", ":=", "c", ".", "acquire", "(", "mSpec", ")", "\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "// Remove from the waiting map.", "delete", "(", "c", ".", "waiting", ",", "id", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "c", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "spec", ".", "Worker", ",", "spec", ".", "Comment", ")", "\n", "c", ".", "holder", "=", "current", "\n", "current", ".", "acquired", "=", "c", ".", "clock", ".", "Now", "(", ")", "\n", "return", "func", "(", ")", "{", "// We need to acquire the mutex before we call the releaser", "// to ensure that we move the current to the history before", "// another pending acquisition overwrites the current value.", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "// We write the log file entry before we release the execution", "// lock to ensure that no other agent is attempting to write to the", "// log file.", "current", ".", "released", "=", "c", ".", "clock", ".", "Now", "(", ")", "\n", "c", ".", "writeLogEntry", "(", ")", "\n", "c", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "spec", ".", "Worker", ",", "spec", ".", "Comment", ")", "\n", "releaser", ".", "Release", "(", ")", "\n", "c", ".", "history", ".", "PushFront", "(", "current", ")", "\n", "c", ".", "holder", "=", "nil", "\n", "}", ",", "nil", "\n", "}" ]

[ "Acquire", "will", "attempt", "to", "acquire", "the", "machine", "hook", "execution", "lock", ".", "The", "method", "returns", "an", "error", "if", "the", "spec", "is", "invalid", "or", "if", "the", "Cancel", "channel", "is", "signalled", "before", "the", "lock", "is", "acquired", "." ]

[ "func", "(", "c", "*", "configCommand", ")", "Info", "(", ")", "*", "cmd", ".", "Info", "{", "return", "jujucmd", ".", "Info", "(", "&", "cmd", ".", "Info", "{", "Name", ":", "\"", "\"", ",", "Args", ":", "\"", "\"", ",", "Purpose", ":", "\"", "\"", ",", "Doc", ":", "strings", ".", "TrimSpace", "(", "configCommandHelpDoc", ")", ",", "}", ")", "\n", "}" ]

[ "Info", "returns", "information", "about", "this", "command", "-", "it", "s", "part", "of", "cmd", ".", "Command", "." ]

[ "func", "(", "c", "*", "configCommand", ")", "SetFlags", "(", "f", "*", "gnuflag", ".", "FlagSet", ")", "{", "c", ".", "ControllerCommandBase", ".", "SetFlags", "(", "f", ")", "\n", "c", ".", "out", ".", "AddFlags", "(", "f", ",", "\"", "\"", ",", "map", "[", "string", "]", "cmd", ".", "Formatter", "{", "\"", "\"", ":", "cmd", ".", "FormatJson", ",", "\"", "\"", ":", "formatConfigTabular", ",", "\"", "\"", ":", "cmd", ".", "FormatYaml", ",", "}", ")", "\n", "}" ]

[ "SetFlags", "adds", "command", "-", "specific", "flags", "to", "the", "flag", "set", ".", "It", "s", "part", "of", "cmd", ".", "Command", "." ]

[ "func", "(", "c", "*", "configCommand", ")", "Init", "(", "args", "[", "]", "string", ")", "error", "{", "switch", "len", "(", "args", ")", "{", "case", "0", ":", "return", "c", ".", "handleZeroArgs", "(", ")", "\n", "case", "1", ":", "return", "c", ".", "handleOneArg", "(", "args", "[", "0", "]", ")", "\n", "default", ":", "return", "c", ".", "handleArgs", "(", "args", ")", "\n", "}", "\n", "}" ]

[ "Init", "initialised", "the", "command", "from", "the", "arguments", "-", "it", "s", "part", "of", "cmd", ".", "Command", "." ]

[ "func", "(", "c", "*", "configCommand", ")", "Run", "(", "ctx", "*", "cmd", ".", "Context", ")", "error", "{", "client", ",", "err", ":=", "c", ".", "getAPI", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "return", "c", ".", "action", "(", "client", ",", "ctx", ")", "\n", "}" ]

[ "Run", "executes", "the", "command", "as", "directed", "by", "the", "options", "and", "arguments", ".", "It", "s", "part", "of", "cmd", ".", "Command", "." ]

[ "func", "NewServiceManagerWithDefaults", "(", ")", "SystemdServiceManager", "{", "return", "NewServiceManager", "(", "systemd", ".", "IsRunning", ",", "func", "(", "name", "string", ",", "conf", "common", ".", "Conf", ")", "(", "Service", ",", "error", ")", "{", "return", "systemd", ".", "NewServiceWithDefaults", "(", "name", ",", "conf", ")", "\n", "}", ",", ")", "\n", "}" ]

[ "NewServiceManagerWithDefaults", "returns", "a", "SystemdServiceManager", "created", "with", "sensible", "defaults", "." ]

[ "func", "NewServiceManager", "(", "isRunning", "func", "(", ")", "bool", ",", "newService", "func", "(", "string", ",", "common", ".", "Conf", ")", "(", "Service", ",", "error", ")", ",", ")", "SystemdServiceManager", "{", "return", "&", "systemdServiceManager", "{", "isRunning", ":", "isRunning", ",", "newService", ":", "newService", ",", "}", "\n", "}" ]

[ "NewServiceManager", "allows", "creation", "of", "a", "new", "SystemdServiceManager", "from", "custom", "dependencies", "." ]

[ "func", "(", "s", "*", "systemdServiceManager", ")", "FindAgents", "(", "dataDir", "string", ")", "(", "string", ",", "[", "]", "string", ",", "[", "]", "string", ",", "error", ")", "{", "var", "(", "machineAgent", "string", "\n", "unitAgents", "[", "]", "string", "\n", "errAgentNames", "[", "]", "string", "\n", ")", "\n\n", "agentDir", ":=", "filepath", ".", "Join", "(", "dataDir", ",", "\"", "\"", ")", "\n", "dir", ",", "err", ":=", "os", ".", "Open", "(", "agentDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "dir", ".", "Close", "(", ")", "\n\n", "entries", ",", "err", ":=", "dir", ".", "Readdir", "(", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "info", ":=", "range", "entries", "{", "name", ":=", "info", ".", "Name", "(", ")", "\n", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "switch", "tag", ".", "Kind", "(", ")", "{", "case", "names", ".", "MachineTagKind", ":", "machineAgent", "=", "name", "\n", "case", "names", ".", "UnitTagKind", ":", "unitAgents", "=", "append", "(", "unitAgents", ",", "name", ")", "\n", "default", ":", "errAgentNames", "=", "append", "(", "errAgentNames", ",", "name", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "}", "\n", "return", "machineAgent", ",", "unitAgents", ",", "errAgentNames", ",", "nil", "\n", "}" ]

[ "FindAgents", "finds", "all", "the", "agents", "available", "on", "the", "machine", "." ]

[ "func", "(", "s", "*", "systemdServiceManager", ")", "CreateAgentConf", "(", "name", "string", ",", "dataDir", "string", ")", "(", "_", "common", ".", "Conf", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "renderer", ",", "err", ":=", "shell", ".", "NewRenderer", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "common", ".", "Conf", "{", "}", ",", "err", "\n", "}", "\n\n", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "common", ".", "Conf", "{", "}", ",", "err", "\n", "}", "\n\n", "var", "kind", "AgentKind", "\n", "switch", "tag", ".", "Kind", "(", ")", "{", "case", "names", ".", "MachineTagKind", ":", "kind", "=", "AgentKindMachine", "\n", "case", "names", ".", "UnitTagKind", ":", "kind", "=", "AgentKindUnit", "\n", "default", ":", "return", "common", ".", "Conf", "{", "}", ",", "errors", ".", "NewNotValid", "(", "nil", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "}", "\n\n", "srvPath", ":=", "path", ".", "Join", "(", "paths", ".", "NixLogDir", ",", "\"", "\"", ")", "\n", "info", ":=", "NewAgentInfo", "(", "kind", ",", "tag", ".", "Id", "(", ")", ",", "dataDir", ",", "srvPath", ")", "\n", "return", "AgentConf", "(", "info", ",", "renderer", ")", ",", "nil", "\n", "}" ]

[ "CreateAgentConf", "creates", "the", "configfile", "for", "specified", "agent", "running", "on", "a", "host", "with", "specified", "series", "." ]

[ "func", "(", "s", "*", "systemdServiceManager", ")", "CopyAgentBinary", "(", "machineAgent", "string", ",", "unitAgents", "[", "]", "string", ",", "dataDir", ",", "toSeries", ",", "fromSeries", "string", ",", "jujuVersion", "version", ".", "Number", ",", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Setup new and old version.Binary instances with different series.", "fromVers", ":=", "version", ".", "Binary", "{", "Number", ":", "jujuVersion", ",", "Arch", ":", "arch", ".", "HostArch", "(", ")", ",", "Series", ":", "fromSeries", ",", "}", "\n", "toVers", ":=", "version", ".", "Binary", "{", "Number", ":", "jujuVersion", ",", "Arch", ":", "arch", ".", "HostArch", "(", ")", ",", "Series", ":", "toSeries", ",", "}", "\n\n", "// If tools with the new series don't already exist, copy", "// current tools to new directory with correct series.", "if", "_", ",", "err", "=", "os", ".", "Stat", "(", "tools", ".", "SharedToolsDir", "(", "dataDir", ",", "toVers", ")", ")", ";", "err", "!=", "nil", "{", "// Copy tools to new directory with correct series.", "if", "err", "=", "fs", ".", "Copy", "(", "tools", ".", "SharedToolsDir", "(", "dataDir", ",", "fromVers", ")", ",", "tools", ".", "SharedToolsDir", "(", "dataDir", ",", "toVers", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Write tools metadata with new version, however don't change", "// the URL, so we know where it came from.", "jujuTools", ",", "err", ":=", "tools", ".", "ReadTools", "(", "dataDir", ",", "toVers", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Only write once", "if", "jujuTools", ".", "Version", "!=", "toVers", "{", "jujuTools", ".", "Version", "=", "toVers", "\n", "if", "err", "=", "tools", ".", "WriteToolsMetadataData", "(", "tools", ".", "ToolsDir", "(", "dataDir", ",", "toVers", ".", "String", "(", ")", ")", ",", "jujuTools", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Update Agent Tool links", "var", "lastError", "error", "\n", "for", "_", ",", "agentName", ":=", "range", "append", "(", "unitAgents", ",", "machineAgent", ")", "{", "toolPath", ":=", "tools", ".", "ToolsDir", "(", "dataDir", ",", "toVers", ".", "String", "(", ")", ")", "\n", "toolsDir", ":=", "tools", ".", "ToolsDir", "(", "dataDir", ",", "agentName", ")", "\n\n", "err", "=", "symlink", ".", "Replace", "(", "toolsDir", ",", "toolPath", ")", "\n", "if", "err", "!=", "nil", "{", "lastError", "=", "err", "\n", "}", "\n", "}", "\n\n", "return", "lastError", "\n", "}" ]

[ "CopyAgentBinary", "copies", "all", "the", "tools", "into", "the", "path", "specified", "for", "each", "agent", "." ]

[ "func", "(", "s", "*", "systemdServiceManager", ")", "StartAllAgents", "(", "machineAgent", "string", ",", "unitAgents", "[", "]", "string", ",", "dataDir", "string", ",", ")", "(", "string", ",", "[", "]", "string", ",", "error", ")", "{", "if", "!", "s", ".", "isRunning", "(", ")", "{", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "startedUnits", "[", "]", "string", "\n", "for", "_", ",", "unit", ":=", "range", "unitAgents", "{", "if", "err", ":=", "s", ".", "startAgent", "(", "unit", ",", "AgentKindUnit", ",", "dataDir", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "startedUnits", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "serviceName", "(", "unit", ")", ")", "\n", "}", "\n", "startedUnits", "=", "append", "(", "startedUnits", ",", "serviceName", "(", "unit", ")", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "serviceName", "(", "unit", ")", ")", "\n", "}", "\n\n", "machineService", ":=", "serviceName", "(", "machineAgent", ")", "\n", "err", ":=", "s", ".", "startAgent", "(", "machineAgent", ",", "AgentKindMachine", ",", "dataDir", ")", "\n", "if", "err", "==", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "machineService", ")", "\n", "return", "machineService", ",", "startedUnits", ",", "nil", "\n", "}", "\n\n", "return", "\"", "\"", ",", "startedUnits", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "machineService", ")", "\n", "}" ]

[ "StartAllAgents", "starts", "all", "of", "the", "input", "agents", "." ]

[ "func", "newConfigWatcher", "(", "keys", "[", "]", "string", ",", "cache", "*", "hashCache", ",", "hub", "*", "pubsub", ".", "SimpleHub", ",", "topic", "string", ",", "res", "*", "Resident", ",", ")", "*", "ConfigWatcher", "{", "sort", ".", "Strings", "(", "keys", ")", "\n\n", "w", ":=", "&", "ConfigWatcher", "{", "notifyWatcherBase", ":", "newNotifyWatcherBase", "(", ")", ",", "keys", ":", "keys", ",", "hash", ":", "cache", ".", "getHash", "(", "keys", ")", ",", "}", "\n\n", "deregister", ":=", "res", ".", "registerWorker", "(", "w", ")", "\n", "unsub", ":=", "hub", ".", "Subscribe", "(", "topic", ",", "w", ".", "configChanged", ")", "\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "<-", "w", ".", "tomb", ".", "Dying", "(", ")", "\n", "unsub", "(", ")", "\n", "deregister", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n\n", "return", "w", "\n", "}" ]

[ "newConfigWatcher", "returns", "a", "new", "watcher", "for", "the", "input", "config", "keys", "with", "a", "baseline", "hash", "of", "their", "config", "values", "from", "the", "input", "hash", "cache", ".", "As", "per", "the", "cache", "requirements", "hashes", "are", "only", "generated", "from", "sorted", "keys", "." ]

[ "func", "(", "w", "*", "stringsWatcherBase", ")", "Changes", "(", ")", "<-", "chan", "[", "]", "string", "{", "w", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "w", ".", "changes", "\n", "}" ]

[ "Changes", "is", "part", "of", "the", "core", "watcher", "definition", ".", "The", "changes", "channel", "is", "never", "closed", "." ]

[ "func", "(", "w", "*", "stringsWatcherBase", ")", "Kill", "(", ")", "{", "w", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "w", ".", "closed", "{", "return", "\n", "}", "\n\n", "w", ".", "closed", "=", "true", "\n", "close", "(", "w", ".", "changes", ")", "\n", "w", ".", "tomb", ".", "Kill", "(", "nil", ")", "\n", "}" ]

[ "Kill", "is", "part", "of", "the", "worker", ".", "Worker", "interface", "." ]

[ "func", "(", "w", "*", "stringsWatcherBase", ")", "amendBufferedChange", "(", "values", "[", "]", "string", ")", "{", "select", "{", "case", "old", ":=", "<-", "w", ".", "changes", ":", "w", ".", "changes", "<-", "set", ".", "NewStrings", "(", "old", "...", ")", ".", "Union", "(", "set", ".", "NewStrings", "(", "values", "...", ")", ")", ".", "Values", "(", ")", "\n", "default", ":", "// Someone read the channel in the meantime.", "// We know we're locked, so no further writes will have occurred.", "// Just send what we were going to send.", "w", ".", "changes", "<-", "values", "\n", "}", "\n", "}" ]

[ "amendBufferedChange", "alters", "the", "buffered", "notification", "to", "include", "new", "information", ".", "This", "method", "assumes", "lock", "protection", "." ]

[ "func", "newChangeWatcher", "(", "values", "...", "string", ")", "*", "PredicateStringsWatcher", "{", "return", "&", "PredicateStringsWatcher", "{", "stringsWatcherBase", ":", "newStringsWatcherBase", "(", "values", "...", ")", ",", "fn", ":", "func", "(", "string", ")", "bool", "{", "return", "true", "}", ",", "}", "\n", "}" ]

[ "newChangeWatcher", "provides", "a", "PredicateStringsWatcher", "which", "notifies", "with", "all", "strings", "passed", "to", "it", "." ]

[ "func", "newPredicateStringsWatcher", "(", "fn", "predicateFunc", ",", "values", "...", "string", ")", "*", "PredicateStringsWatcher", "{", "return", "&", "PredicateStringsWatcher", "{", "stringsWatcherBase", ":", "newStringsWatcherBase", "(", "values", "...", ")", ",", "fn", ":", "fn", ",", "}", "\n", "}" ]

[ "newPredicateStringsWatcher", "provides", "a", "PredicateStringsWatcher", "which", "notifies", "with", "any", "string", "which", "passes", "the", "predicateFunc", "." ]

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

[ "NewApplicationVersionSetCommand", "creates", "an", "application", "-", "version", "-", "set", "command", "." ]

[ "func", "(", "st", "*", "state", ")", "ConnectStream", "(", "path", "string", ",", "attrs", "url", ".", "Values", ")", "(", "base", ".", "Stream", ",", "error", ")", "{", "path", ",", "err", ":=", "apiPath", "(", "st", ".", "modelTag", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "conn", ",", "err", ":=", "st", ".", "connectStreamWithRetry", "(", "path", ",", "attrs", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "conn", ",", "nil", "\n", "}" ]

[ "ConnectStream", "implements", "StreamConnector", ".", "ConnectStream", ".", "The", "stream", "returned", "will", "apply", "a", "30", "-", "second", "write", "deadline", "so", "WriteJSON", "should", "only", "be", "called", "from", "one", "goroutine", "." ]

[ "func", "(", "st", "*", "state", ")", "connectStream", "(", "path", "string", ",", "attrs", "url", ".", "Values", ",", "extraHeaders", "http", ".", "Header", ")", "(", "base", ".", "Stream", ",", "error", ")", "{", "target", ":=", "url", ".", "URL", "{", "Scheme", ":", "\"", "\"", ",", "Host", ":", "st", ".", "addr", ",", "Path", ":", "path", ",", "RawQuery", ":", "attrs", ".", "Encode", "(", ")", ",", "}", "\n", "// TODO(macgreagoir) IPv6. Ubuntu still always provides IPv4 loopback,", "// and when/if this changes localhost should resolve to IPv6 loopback", "// in any case (lp:1644009). Review.", "dialer", ":=", "&", "websocket", ".", "Dialer", "{", "Proxy", ":", "proxy", ".", "DefaultConfig", ".", "GetProxy", ",", "TLSClientConfig", ":", "st", ".", "tlsConfig", ",", "// In order to deal with the remote side not handling message", "// fragmentation, we default to largeish frames.", "ReadBufferSize", ":", "websocketFrameSize", ",", "WriteBufferSize", ":", "websocketFrameSize", ",", "}", "\n", "var", "requestHeader", "http", ".", "Header", "\n", "if", "st", ".", "tag", "!=", "\"", "\"", "{", "requestHeader", "=", "utils", ".", "BasicAuthHeader", "(", "st", ".", "tag", ",", "st", ".", "password", ")", "\n", "}", "else", "{", "requestHeader", "=", "make", "(", "http", ".", "Header", ")", "\n", "}", "\n", "requestHeader", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "st", ".", "nonce", "!=", "\"", "\"", "{", "requestHeader", ".", "Set", "(", "params", ".", "MachineNonceHeader", ",", "st", ".", "nonce", ")", "\n", "}", "\n", "// Add any cookies because they will not be sent to websocket", "// connections by default.", "err", ":=", "st", ".", "addCookiesToHeader", "(", "requestHeader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "header", ",", "values", ":=", "range", "extraHeaders", "{", "for", "_", ",", "value", ":=", "range", "values", "{", "requestHeader", ".", "Add", "(", "header", ",", "value", ")", "\n", "}", "\n", "}", "\n\n", "connection", ",", "err", ":=", "websocketDial", "(", "dialer", ",", "target", ".", "String", "(", ")", ",", "requestHeader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "readInitialStreamError", "(", "connection", ")", ";", "err", "!=", "nil", "{", "connection", ".", "Close", "(", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "connection", ",", "nil", "\n", "}" ]

[ "connectStream", "is", "the", "internal", "version", "of", "ConnectStream", ".", "It", "differs", "from", "ConnectStream", "only", "in", "that", "it", "will", "not", "retry", "the", "connection", "if", "it", "encounters", "discharge", "-", "required", "error", "." ]

[ "func", "readInitialStreamError", "(", "ws", "base", ".", "Stream", ")", "error", "{", "// We can use bufio here because the websocket guarantees that a", "// single read will not read more than a single frame; there is", "// no guarantee that a single read might not read less than the", "// whole frame though, so using a single Read call is not", "// correct. By using ReadSlice rather than ReadBytes, we", "// guarantee that the error can't be too big (>4096 bytes).", "messageType", ",", "reader", ",", "err", ":=", "ws", ".", "NextReader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "messageType", "!=", "websocket", ".", "TextMessage", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "messageType", ")", "\n", "}", "\n", "line", ",", "err", ":=", "bufio", ".", "NewReader", "(", "reader", ")", ".", "ReadSlice", "(", "'\\n'", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "var", "errResult", "params", ".", "ErrorResult", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "line", ",", "&", "errResult", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "errResult", ".", "Error", "!=", "nil", "{", "return", "errResult", ".", "Error", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "readInitialStreamError", "reads", "the", "initial", "error", "response", "from", "a", "stream", "connection", "and", "returns", "it", "." ]

[ "func", "(", "st", "*", "state", ")", "addCookiesToHeader", "(", "h", "http", ".", "Header", ")", "error", "{", "// net/http only allows adding cookies to a request,", "// but when it sends a request to a non-http endpoint,", "// it doesn't add the cookies, so make a request, starting", "// with the given header, add the cookies to use, then", "// throw away the request but keep the header.", "req", ":=", "&", "http", ".", "Request", "{", "Header", ":", "h", ",", "}", "\n", "cookies", ":=", "st", ".", "bakeryClient", ".", "Client", ".", "Jar", ".", "Cookies", "(", "st", ".", "cookieURL", ")", "\n", "for", "_", ",", "c", ":=", "range", "cookies", "{", "req", ".", "AddCookie", "(", "c", ")", "\n", "}", "\n", "if", "len", "(", "cookies", ")", "==", "0", "&&", "len", "(", "st", ".", "macaroons", ")", ">", "0", "{", "// These macaroons must have been added directly rather than", "// obtained from a request. Add them. (For example in the", "// logtransfer connection for a migration.)", "// See https://bugs.launchpad.net/juju/+bug/1650451", "for", "_", ",", "macaroon", ":=", "range", "st", ".", "macaroons", "{", "cookie", ",", "err", ":=", "httpbakery", ".", "NewCookie", "(", "macaroon", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "req", ".", "AddCookie", "(", "cookie", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "addCookiesToHeader", "adds", "any", "cookies", "associated", "with", "the", "API", "host", "to", "the", "given", "header", ".", "This", "is", "necessary", "because", "otherwise", "cookies", "are", "not", "sent", "to", "websocket", "endpoints", "." ]

[ "func", "(", "st", "*", "state", ")", "apiEndpoint", "(", "path", ",", "query", "string", ")", "(", "*", "url", ".", "URL", ",", "error", ")", "{", "path", ",", "err", ":=", "apiPath", "(", "st", ".", "modelTag", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "url", ".", "URL", "{", "Scheme", ":", "st", ".", "serverScheme", ",", "Host", ":", "st", ".", "Addr", "(", ")", ",", "Path", ":", "path", ",", "RawQuery", ":", "query", ",", "}", ",", "nil", "\n", "}" ]

[ "apiEndpoint", "returns", "a", "URL", "that", "refers", "to", "the", "given", "API", "slash", "-", "prefixed", "endpoint", "path", "and", "query", "parameters", "." ]

[ "func", "(", "s", "*", "state", ")", "Ping", "(", ")", "error", "{", "return", "s", ".", "APICall", "(", "\"", "\"", ",", "s", ".", "pingerFacadeVersion", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "Ping", "implements", "api", ".", "Connection", "." ]

[ "func", "apiPath", "(", "modelTag", "names", ".", "ModelTag", ",", "path", "string", ")", "(", "string", ",", "error", ")", "{", "if", "!", "strings", ".", "HasPrefix", "(", "path", ",", "\"", "\"", ")", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "modelUUID", ":=", "modelTag", ".", "Id", "(", ")", "\n", "if", "modelUUID", "==", "\"", "\"", "{", "return", "path", ",", "nil", "\n", "}", "\n", "return", "modelRoot", "+", "modelUUID", "+", "path", ",", "nil", "\n", "}" ]

[ "apiPath", "returns", "the", "given", "API", "endpoint", "path", "relative", "to", "the", "given", "model", "tag", "." ]

[ "func", "dialAPI", "(", "ctx", "context", ".", "Context", ",", "info", "*", "Info", ",", "opts0", "DialOpts", ")", "(", "*", "dialResult", ",", "error", ")", "{", "if", "len", "(", "info", ".", "Addrs", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "opts", ":=", "dialOpts", "{", "DialOpts", ":", "opts0", ",", "sniHostName", ":", "info", ".", "SNIHostName", ",", "}", "\n", "if", "info", ".", "CACert", "!=", "\"", "\"", "{", "certPool", ",", "err", ":=", "CreateCertPool", "(", "info", ".", "CACert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "opts", ".", "certPool", "=", "certPool", "\n", "}", "\n", "// Set opts.DialWebsocket and opts.Clock here rather than in open because", "// some tests call dialAPI directly.", "if", "opts", ".", "DialWebsocket", "==", "nil", "{", "opts", ".", "DialWebsocket", "=", "gorillaDialWebsocket", "\n", "}", "\n", "if", "opts", ".", "IPAddrResolver", "==", "nil", "{", "opts", ".", "IPAddrResolver", "=", "net", ".", "DefaultResolver", "\n", "}", "\n", "if", "opts", ".", "Clock", "==", "nil", "{", "opts", ".", "Clock", "=", "clock", ".", "WallClock", "\n", "}", "\n", "if", "opts", ".", "DNSCache", "==", "nil", "{", "opts", ".", "DNSCache", "=", "nopDNSCache", "{", "}", "\n", "}", "\n", "path", ",", "err", ":=", "apiPath", "(", "info", ".", "ModelTag", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Encourage load balancing by shuffling controller addresses.", "addrs", ":=", "info", ".", "Addrs", "[", ":", "]", "\n", "rand", ".", "Shuffle", "(", "len", "(", "addrs", ")", ",", "func", "(", "i", ",", "j", "int", ")", "{", "addrs", "[", "i", "]", ",", "addrs", "[", "j", "]", "=", "addrs", "[", "j", "]", ",", "addrs", "[", "i", "]", "}", ")", "\n\n", "if", "opts", ".", "VerifyCA", "!=", "nil", "{", "if", "err", ":=", "verifyCAMulti", "(", "ctx", ",", "addrs", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "DialTimeout", ">", "0", "{", "ctx1", ",", "cancel", ":=", "utils", ".", "ContextWithTimeout", "(", "ctx", ",", "opts", ".", "Clock", ",", "opts", ".", "DialTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "ctx", "=", "ctx1", "\n", "}", "\n", "dialInfo", ",", "err", ":=", "dialWebsocketMulti", "(", "ctx", ",", "addrs", ",", "path", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "dialInfo", ".", "urlStr", ")", "\n", "return", "dialInfo", ",", "nil", "\n", "}" ]

[ "dialAPI", "establishes", "a", "websocket", "connection", "to", "the", "RPC", "API", "websocket", "on", "the", "API", "server", "using", "Info", ".", "If", "multiple", "API", "addresses", "are", "provided", "in", "Info", "they", "will", "be", "tried", "concurrently", "-", "the", "first", "successful", "connection", "wins", ".", "It", "also", "returns", "the", "TLS", "configuration", "that", "it", "has", "derived", "from", "the", "Info", "." ]

[ "func", "gorillaDialWebsocket", "(", "ctx", "context", ".", "Context", ",", "urlStr", "string", ",", "tlsConfig", "*", "tls", ".", "Config", ",", "ipAddr", "string", ")", "(", "jsoncodec", ".", "JSONConn", ",", "error", ")", "{", "url", ",", "err", ":=", "url", ".", "Parse", "(", "urlStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// TODO(rogpeppe) We'd like to set Deadline here", "// but that would break lots of tests that rely on", "// setting a zero timeout.", "netDialer", ":=", "net", ".", "Dialer", "{", "}", "\n", "dialer", ":=", "&", "websocket", ".", "Dialer", "{", "NetDial", ":", "func", "(", "netw", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "if", "addr", "==", "url", ".", "Host", "{", "// Use pre-resolved IP address. The address", "// may be different if a proxy is in use.", "addr", "=", "ipAddr", "\n", "}", "\n", "return", "netDialer", ".", "DialContext", "(", "ctx", ",", "netw", ",", "addr", ")", "\n", "}", ",", "Proxy", ":", "proxy", ".", "DefaultConfig", ".", "GetProxy", ",", "HandshakeTimeout", ":", "45", "*", "time", ".", "Second", ",", "TLSClientConfig", ":", "tlsConfig", ",", "// In order to deal with the remote side not handling message", "// fragmentation, we default to largeish frames.", "ReadBufferSize", ":", "websocketFrameSize", ",", "WriteBufferSize", ":", "websocketFrameSize", ",", "}", "\n", "// Note: no extra headers.", "c", ",", "resp", ",", "err", ":=", "dialer", ".", "Dial", "(", "urlStr", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "websocket", ".", "ErrBadHandshake", "{", "// If ErrBadHandshake is returned, a non-nil response", "// is returned so the client can react to auth errors", "// (for example).", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "body", ",", "readErr", ":=", "ioutil", ".", "ReadAll", "(", "resp", ".", "Body", ")", "\n", "if", "readErr", "==", "nil", "{", "err", "=", "errors", ".", "Errorf", "(", "\"", "\"", ",", "strings", ".", "TrimSpace", "(", "string", "(", "body", ")", ")", ",", "http", ".", "StatusText", "(", "resp", ".", "StatusCode", ")", ",", ")", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "jsoncodec", ".", "NewWebsocketConn", "(", "c", ")", ",", "nil", "\n", "}" ]

[ "gorillaDialWebsocket", "makes", "a", "websocket", "connection", "using", "the", "gorilla", "websocket", "package", ".", "The", "ipAddr", "parameter", "holds", "the", "actual", "IP", "address", "that", "will", "be", "contacted", "-", "the", "host", "in", "urlStr", "is", "used", "only", "for", "TLS", "verification", "when", "tlsConfig", ".", "ServerName", "is", "empty", "." ]

[ "func", "(", "ap", "*", "addressProvider", ")", "next", "(", "ctx", "context", ".", "Context", ")", "(", "*", "resolvedAddress", ",", "error", ")", "{", "if", "len", "(", "ap", ".", "resolvedAddrs", ")", "==", "0", "{", "// If we have ran out of addresses to resolve but we have", "// resolved some via the DNS cache, make another pass for", "// those with an empty DNS cache to refresh any stale entries.", "if", "len", "(", "ap", ".", "addrPool", ")", "==", "0", "&&", "len", "(", "ap", ".", "cachedAddrPool", ")", ">", "0", "{", "ap", ".", "addrPool", "=", "ap", ".", "cachedAddrPool", "\n", "ap", ".", "cachedAddrPool", "=", "nil", "\n", "ap", ".", "dnsCache", "=", "emptyDNSCache", "{", "ap", ".", "dnsCache", "}", "\n", "}", "\n\n", "// Resolve the next host from the address pool", "if", "len", "(", "ap", ".", "addrPool", ")", "!=", "0", "{", "next", ":=", "ap", ".", "addrPool", "[", "0", "]", "\n", "ap", ".", "addrPool", "=", "ap", ".", "addrPool", "[", "1", ":", "]", "\n\n", "host", ",", "port", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "next", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "next", ",", "err", ")", "\n", "}", "\n\n", "ips", ":=", "ap", ".", "dnsCache", ".", "Lookup", "(", "host", ")", "\n", "if", "len", "(", "ips", ")", ">", "0", "{", "ap", ".", "cachedAddrPool", "=", "append", "(", "ap", ".", "cachedAddrPool", ",", "next", ")", "\n", "}", "else", "if", "isNumericHost", "(", "host", ")", "{", "ips", "=", "[", "]", "string", "{", "host", "}", "\n", "}", "else", "{", "var", "err", "error", "\n", "ips", ",", "err", "=", "lookupIPAddr", "(", "ctx", ",", "host", ",", "ap", ".", "ipAddrResolver", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "host", ",", "err", ")", "\n", "}", "\n", "ap", ".", "dnsCache", ".", "Add", "(", "host", ",", "ips", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "host", ",", "ips", ")", "\n", "}", "\n\n", "for", "_", ",", "ip", ":=", "range", "ips", "{", "ap", ".", "resolvedAddrs", "=", "append", "(", "ap", ".", "resolvedAddrs", ",", "&", "resolvedAddress", "{", "host", ":", "next", ",", "ip", ":", "ip", ",", "port", ":", "port", ",", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Ran out of resolved addresses and cached addresses", "if", "len", "(", "ap", ".", "resolvedAddrs", ")", "==", "0", "{", "return", "nil", ",", "io", ".", "EOF", "\n", "}", "\n\n", "next", ":=", "ap", ".", "resolvedAddrs", "[", "0", "]", "\n", "ap", ".", "resolvedAddrs", "=", "ap", ".", "resolvedAddrs", "[", "1", ":", "]", "\n", "return", "next", ",", "nil", "\n", "}" ]

[ "next", "returns", "back", "either", "a", "successfully", "resolved", "address", "or", "the", "error", "that", "occurred", "while", "attempting", "to", "resolve", "the", "next", "address", "candidate", ".", "Calls", "to", "next", "return", "io", ".", "EOF", "to", "indicate", "that", "no", "more", "addresses", "are", "available", "." ]

[ "func", "verifyCAMulti", "(", "ctx", "context", ".", "Context", ",", "addrs", "[", "]", "string", ",", "opts", "*", "dialOpts", ")", "error", "{", "dOpts", ":=", "opts", ".", "DialOpts", "\n", "if", "dOpts", ".", "DialTimeout", ">", "0", "{", "ctx1", ",", "cancel", ":=", "utils", ".", "ContextWithTimeout", "(", "ctx", ",", "dOpts", ".", "Clock", ",", "dOpts", ".", "DialTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "ctx", "=", "ctx1", "\n", "}", "\n\n", "try", ":=", "parallel", ".", "NewTry", "(", "0", ",", "nil", ")", "\n", "defer", "try", ".", "Kill", "(", ")", "\n\n", "addrProvider", ":=", "newAddressProvider", "(", "addrs", ",", "opts", ".", "DNSCache", ",", "opts", ".", "IPAddrResolver", ")", "\n", "tryRetrieveCaCertFn", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "addr", "*", "resolvedAddress", ")", "func", "(", "<-", "chan", "struct", "{", "}", ")", "(", "io", ".", "Closer", ",", "error", ")", "{", "ipStr", ":=", "net", ".", "JoinHostPort", "(", "addr", ".", "ip", ",", "addr", ".", "port", ")", "\n", "return", "func", "(", "<-", "chan", "struct", "{", "}", ")", "(", "io", ".", "Closer", ",", "error", ")", "{", "caCert", ",", "err", ":=", "retrieveCACert", "(", "ctx", ",", "ipStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "caRetrieveRes", "{", "host", ":", "addr", ".", "host", ",", "endpoint", ":", "ipStr", ",", "caCert", ":", "caCert", ",", "}", ",", "nil", "\n", "}", "\n", "}", "\n\n", "for", "{", "resolvedAddr", ",", "err", ":=", "addrProvider", ".", "next", "(", "ctx", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "else", "if", "err", "!=", "nil", "{", "recordTryError", "(", "try", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "err", "=", "try", ".", "Start", "(", "tryRetrieveCaCertFn", "(", "ctx", ",", "resolvedAddr", ")", ")", "\n", "if", "err", "==", "parallel", ".", "ErrStopped", "{", "break", "\n", "}", "else", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n\n", "select", "{", "case", "<-", "opts", ".", "Clock", ".", "After", "(", "dOpts", ".", "DialAddressInterval", ")", ":", "case", "<-", "try", ".", "Dead", "(", ")", ":", "}", "\n", "}", "\n\n", "try", ".", "Close", "(", ")", "\n\n", "// If we are unable to fetch the CA either because it is not presented", "// by the remote server OR due to an unsuccessful connection attempt", "// we should skip the verification path and dial the server as if no", "// VerifyCA implementation was provided.", "result", ",", "err", ":=", "try", ".", "Result", "(", ")", "\n", "if", "err", "!=", "nil", "||", "result", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// Try to verify CA cert using the system roots. If the verification", "// succeeds then we are done; tls connections will work out of the box.", "res", ":=", "result", ".", "(", "caRetrieveRes", ")", "\n", "if", "_", ",", "err", "=", "res", ".", "caCert", ".", "Verify", "(", "x509", ".", "VerifyOptions", "{", "}", ")", ";", "err", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// Invoke the CA verifier; if the CA should be trusted, append it to", "// the dialOpts certPool and proceed with the actual connection attempt.", "err", "=", "opts", ".", "VerifyCA", "(", "res", ".", "host", ",", "res", ".", "endpoint", ",", "res", ".", "caCert", ")", "\n", "if", "err", "==", "nil", "{", "if", "opts", ".", "certPool", "==", "nil", "{", "opts", ".", "certPool", "=", "x509", ".", "NewCertPool", "(", ")", "\n", "}", "\n", "opts", ".", "certPool", ".", "AddCert", "(", "res", ".", "caCert", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "verifyCAMulti", "attempts", "to", "establish", "a", "TLS", "connection", "with", "one", "of", "the", "provided", "addresses", "retrieve", "the", "CA", "certificate", "and", "validate", "it", "using", "the", "system", "root", "CAs", ".", "If", "that", "is", "not", "possible", "the", "certificate", "verification", "will", "be", "delegated", "to", "the", "VerifyCA", "implementation", "specified", "in", "opts", ".", "DialOpts", ".", "If", "VerifyCA", "does", "not", "return", "an", "error", "the", "CA", "cert", "is", "assumed", "to", "be", "trusted", "and", "will", "be", "appended", "to", "opt", "s", "certificate", "pool", "allowing", "secure", "websocket", "connections", "to", "proceed", "without", "certificate", "verification", "errors", ".", "Otherwise", "the", "error", "reported", "by", "VerifyCA", "is", "returned", "back", "to", "the", "caller", ".", "For", "load", "-", "balancing", "purposes", "all", "addresses", "are", "tested", "concurrently", "with", "the", "first", "retrieved", "CA", "cert", "being", "used", "for", "the", "verification", "tests", ".", "In", "addition", "apart", "from", "the", "initial", "TLS", "handshake", "with", "the", "remote", "server", "no", "other", "data", "is", "exchanged", "with", "the", "remote", "server", "." ]

[ "func", "retrieveCACert", "(", "ctx", "context", ".", "Context", ",", "addr", "string", ")", "(", "*", "x509", ".", "Certificate", ",", "error", ")", "{", "netConn", ",", "err", ":=", "new", "(", "net", ".", "Dialer", ")", ".", "DialContext", "(", "ctx", ",", "\"", "\"", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "conn", ":=", "tls", ".", "Client", "(", "netConn", ",", "&", "tls", ".", "Config", "{", "InsecureSkipVerify", ":", "true", "}", ")", "\n", "if", "err", "=", "conn", ".", "Handshake", "(", ")", ";", "err", "!=", "nil", "{", "_", "=", "netConn", ".", "Close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "_", "=", "conn", ".", "Close", "(", ")", "\n", "_", "=", "netConn", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n\n", "for", "_", ",", "cert", ":=", "range", "conn", ".", "ConnectionState", "(", ")", ".", "PeerCertificates", "{", "if", "cert", ".", "IsCA", "{", "return", "cert", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "retrieveCACert", "establishes", "an", "insecure", "TLS", "connection", "to", "addr", "and", "attempts", "to", "retrieve", "the", "CA", "cert", "presented", "by", "the", "server", ".", "If", "no", "CA", "cert", "is", "presented", "retrieveCACert", "will", "returns", "nil", "nil", "." ]

[ "func", "dialWebsocketMulti", "(", "ctx", "context", ".", "Context", ",", "addrs", "[", "]", "string", ",", "path", "string", ",", "opts", "dialOpts", ")", "(", "*", "dialResult", ",", "error", ")", "{", "// Prioritise non-dial errors over the normal \"connection refused\".", "isDialError", ":=", "func", "(", "err", "error", ")", "bool", "{", "netErr", ",", "ok", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "*", "net", ".", "OpError", ")", "\n", "if", "!", "ok", "{", "return", "false", "\n", "}", "\n", "return", "netErr", ".", "Op", "==", "\"", "\"", "\n", "}", "\n", "combine", ":=", "func", "(", "initial", ",", "other", "error", ")", "error", "{", "if", "initial", "==", "nil", "||", "isDialError", "(", "initial", ")", "{", "return", "other", "\n", "}", "\n", "if", "isDialError", "(", "other", ")", "{", "return", "initial", "\n", "}", "\n", "return", "other", "\n", "}", "\n", "// Dial all addresses at reasonable intervals.", "try", ":=", "parallel", ".", "NewTry", "(", "0", ",", "combine", ")", "\n", "defer", "try", ".", "Kill", "(", ")", "\n", "// Make a context that's cancelled when the try", "// completes so that (for example) a slow DNS", "// query will be cancelled if a previous try succeeds.", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "go", "func", "(", ")", "{", "<-", "try", ".", "Dead", "(", ")", "\n", "cancel", "(", ")", "\n", "}", "(", ")", "\n", "tried", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "addrProvider", ":=", "newAddressProvider", "(", "addrs", ",", "opts", ".", "DNSCache", ",", "opts", ".", "IPAddrResolver", ")", "\n", "for", "{", "resolvedAddr", ",", "err", ":=", "addrProvider", ".", "next", "(", "ctx", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "else", "if", "err", "!=", "nil", "{", "recordTryError", "(", "try", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "ipStr", ":=", "net", ".", "JoinHostPort", "(", "resolvedAddr", ".", "ip", ",", "resolvedAddr", ".", "port", ")", "\n", "if", "tried", "[", "ipStr", "]", "{", "continue", "\n", "}", "\n", "tried", "[", "ipStr", "]", "=", "true", "\n", "err", "=", "startDialWebsocket", "(", "ctx", ",", "try", ",", "ipStr", ",", "resolvedAddr", ".", "host", ",", "path", ",", "opts", ")", "\n", "if", "err", "==", "parallel", ".", "ErrStopped", "{", "break", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "select", "{", "case", "<-", "opts", ".", "Clock", ".", "After", "(", "opts", ".", "DialAddressInterval", ")", ":", "case", "<-", "try", ".", "Dead", "(", ")", ":", "}", "\n", "}", "\n", "try", ".", "Close", "(", ")", "\n", "result", ",", "err", ":=", "try", ".", "Result", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "result", ".", "(", "*", "dialResult", ")", ",", "nil", "\n", "}" ]

[ "dialWebsocketMulti", "dials", "a", "websocket", "with", "one", "of", "the", "provided", "addresses", "the", "specified", "URL", "path", "TLS", "configuration", "and", "dial", "options", ".", "Each", "of", "the", "specified", "addresses", "will", "be", "attempted", "concurrently", "and", "the", "first", "successful", "connection", "will", "be", "returned", "." ]

[ "func", "recordTryError", "(", "try", "*", "parallel", ".", "Try", ",", "err", "error", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "try", ".", "Start", "(", "func", "(", "_", "<-", "chan", "struct", "{", "}", ")", "(", "io", ".", "Closer", ",", "error", ")", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", ")", "\n", "}" ]

[ "recordTryError", "starts", "a", "try", "that", "just", "returns", "the", "given", "error", ".", "This", "is", "so", "that", "we", "can", "use", "the", "usual", "Try", "error", "combination", "logic", "even", "for", "errors", "that", "happen", "before", "we", "start", "a", "try", "." ]

[ "func", "startDialWebsocket", "(", "ctx", "context", ".", "Context", ",", "try", "*", "parallel", ".", "Try", ",", "ipAddr", ",", "addr", ",", "path", "string", ",", "opts", "dialOpts", ")", "error", "{", "var", "openAttempt", "retry", ".", "Strategy", "\n", "if", "opts", ".", "RetryDelay", ">", "0", "{", "openAttempt", "=", "retry", ".", "Regular", "{", "Total", ":", "opts", ".", "Timeout", ",", "Delay", ":", "opts", ".", "RetryDelay", ",", "Min", ":", "int", "(", "opts", ".", "Timeout", "/", "opts", ".", "RetryDelay", ")", ",", "}", "\n", "}", "else", "{", "// Zero retry delay implies exactly one try.", "openAttempt", "=", "oneAttempt", "\n", "}", "\n", "d", ":=", "dialer", "{", "ctx", ":", "ctx", ",", "openAttempt", ":", "openAttempt", ",", "serverName", ":", "opts", ".", "sniHostName", ",", "ipAddr", ":", "ipAddr", ",", "urlStr", ":", "\"", "\"", "+", "addr", "+", "path", ",", "addr", ":", "addr", ",", "opts", ":", "opts", ",", "}", "\n", "return", "try", ".", "Start", "(", "d", ".", "dial", ")", "\n", "}" ]

[ "startDialWebsocket", "starts", "websocket", "connection", "to", "a", "single", "address", "on", "the", "given", "try", "instance", "." ]

[ "func", "(", "d", "dialer", ")", "dial", "(", "_", "<-", "chan", "struct", "{", "}", ")", "(", "io", ".", "Closer", ",", "error", ")", "{", "a", ":=", "retry", ".", "StartWithCancel", "(", "d", ".", "openAttempt", ",", "d", ".", "opts", ".", "Clock", ",", "d", ".", "ctx", ".", "Done", "(", ")", ")", "\n", "var", "lastErr", "error", "=", "nil", "\n", "for", "a", ".", "Next", "(", ")", "{", "conn", ",", "tlsConfig", ",", "err", ":=", "d", ".", "dial1", "(", ")", "\n", "if", "err", "==", "nil", "{", "return", "&", "dialResult", "{", "conn", ":", "conn", ",", "addr", ":", "d", ".", "addr", ",", "ipAddr", ":", "d", ".", "ipAddr", ",", "urlStr", ":", "d", ".", "urlStr", ",", "tlsConfig", ":", "tlsConfig", ",", "}", ",", "nil", "\n", "}", "\n", "if", "isX509Error", "(", "err", ")", "||", "!", "a", ".", "More", "(", ")", "{", "// certificate errors don't improve with retries.", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "lastErr", "=", "err", "\n", "}", "\n", "if", "lastErr", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "parallel", ".", "ErrStopped", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "lastErr", ")", "\n", "}" ]

[ "dial", "implements", "the", "function", "value", "expected", "by", "Try", ".", "Start", "by", "dialing", "the", "websocket", "as", "specified", "in", "d", "and", "retrying", "when", "appropriate", "." ]

[ "func", "(", "d", "dialer", ")", "dial1", "(", ")", "(", "jsoncodec", ".", "JSONConn", ",", "*", "tls", ".", "Config", ",", "error", ")", "{", "tlsConfig", ":=", "NewTLSConfig", "(", "d", ".", "opts", ".", "certPool", ")", "\n", "tlsConfig", ".", "InsecureSkipVerify", "=", "d", ".", "opts", ".", "InsecureSkipVerify", "\n", "if", "d", ".", "opts", ".", "certPool", "==", "nil", "{", "tlsConfig", ".", "ServerName", "=", "d", ".", "serverName", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "d", ".", "urlStr", ",", "d", ".", "ipAddr", ")", "\n", "conn", ",", "err", ":=", "d", ".", "opts", ".", "DialWebsocket", "(", "d", ".", "ctx", ",", "d", ".", "urlStr", ",", "tlsConfig", ",", "d", ".", "ipAddr", ")", "\n", "if", "err", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "d", ".", "urlStr", ")", "\n", "return", "conn", ",", "tlsConfig", ",", "nil", "\n", "}", "\n", "if", "!", "isX509Error", "(", "err", ")", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "tlsConfig", ".", "RootCAs", "==", "nil", "||", "d", ".", "serverName", "==", "\"", "\"", "{", "// There's no private certificate or we don't have a", "// public hostname. In the former case, we've already", "// tried public certificates; in the latter, public cert", "// validation won't help, because you generally can't", "// obtain a public cert for a numeric IP address. In", "// both those cases, we won't succeed when trying again", "// because a cert error isn't temporary, so return", "// immediately.", "//", "// Note that the error returned from", "// websocket.DialConfig always includes the location in", "// the message.", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// It's possible we're inappropriately using the private", "// CA certificate, so retry immediately with the public one.", "tlsConfig", ".", "RootCAs", "=", "nil", "\n", "tlsConfig", ".", "ServerName", "=", "d", ".", "serverName", "\n", "conn", ",", "rootCAErr", ":=", "d", ".", "opts", ".", "DialWebsocket", "(", "d", ".", "ctx", ",", "d", ".", "urlStr", ",", "tlsConfig", ",", "d", ".", "ipAddr", ")", "\n", "if", "rootCAErr", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "rootCAErr", ")", "\n", "// We return the original error as it's usually more meaningful.", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "conn", ",", "tlsConfig", ",", "nil", "\n", "}" ]

[ "dial1", "makes", "a", "single", "dial", "attempt", "." ]

[ "func", "isX509Error", "(", "err", "error", ")", "bool", "{", "switch", "errType", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "*", "websocket", ".", "CloseError", ":", "return", "errType", ".", "Code", "==", "websocket", ".", "CloseTLSHandshake", "\n", "case", "x509", ".", "CertificateInvalidError", ",", "x509", ".", "HostnameError", ",", "x509", ".", "InsecureAlgorithmError", ",", "x509", ".", "UnhandledCriticalExtension", ",", "x509", ".", "UnknownAuthorityError", ",", "x509", ".", "ConstraintViolationError", ",", "x509", ".", "SystemRootsError", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "isX509Error", "reports", "whether", "the", "given", "websocket", "error", "results", "from", "an", "X509", "problem", "." ]

[ "func", "(", "s", "*", "state", ")", "APICall", "(", "facade", "string", ",", "version", "int", ",", "id", ",", "method", "string", ",", "args", ",", "response", "interface", "{", "}", ")", "error", "{", "for", "a", ":=", "retry", ".", "Start", "(", "apiCallRetryStrategy", ",", "s", ".", "clock", ")", ";", "a", ".", "Next", "(", ")", ";", "{", "err", ":=", "s", ".", "client", ".", "Call", "(", "rpc", ".", "Request", "{", "Type", ":", "facade", ",", "Version", ":", "version", ",", "Id", ":", "id", ",", "Action", ":", "method", ",", "}", ",", "args", ",", "response", ")", "\n", "if", "params", ".", "ErrCode", "(", "err", ")", "!=", "params", ".", "CodeRetry", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "a", ".", "More", "(", ")", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "APICall", "places", "a", "call", "to", "the", "remote", "machine", ".", "This", "fills", "out", "the", "rpc", ".", "Request", "on", "the", "given", "facade", "version", "for", "a", "given", "object", "id", "and", "the", "specific", "RPC", "method", ".", "It", "marshalls", "the", "Arguments", "and", "will", "unmarshall", "the", "result", "into", "the", "response", "object", "that", "is", "supplied", "." ]

[ "func", "(", "s", "*", "state", ")", "IsBroken", "(", ")", "bool", "{", "select", "{", "case", "<-", "s", ".", "broken", ":", "return", "true", "\n", "default", ":", "}", "\n", "if", "err", ":=", "s", ".", "Ping", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsBroken", "implements", "api", ".", "Connection", "." ]

[ "func", "(", "s", "*", "state", ")", "ModelTag", "(", ")", "(", "names", ".", "ModelTag", ",", "bool", ")", "{", "return", "s", ".", "modelTag", ",", "s", ".", "modelTag", ".", "Id", "(", ")", "!=", "\"", "\"", "\n", "}" ]

[ "ModelTag", "implements", "base", ".", "APICaller", ".", "ModelTag", "." ]

[ "func", "(", "s", "*", "state", ")", "AllFacadeVersions", "(", ")", "map", "[", "string", "]", "[", "]", "int", "{", "facades", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "int", ",", "len", "(", "s", ".", "facadeVersions", ")", ")", "\n", "for", "name", ",", "versions", ":=", "range", "s", ".", "facadeVersions", "{", "facades", "[", "name", "]", "=", "append", "(", "[", "]", "int", "{", "}", ",", "versions", "...", ")", "\n", "}", "\n", "return", "facades", "\n", "}" ]

[ "AllFacadeVersions", "returns", "what", "versions", "we", "know", "about", "for", "all", "facades" ]

[ "func", "NewDefaultsCommand", "(", ")", "cmd", ".", "Command", "{", "defaultsCmd", ":=", "&", "defaultsCommand", "{", "newCloudAPI", ":", "func", "(", "caller", "base", ".", "APICallCloser", ")", "cloudAPI", "{", "return", "cloudapi", ".", "NewClient", "(", "caller", ")", "\n", "}", ",", "newDefaultsAPI", ":", "func", "(", "caller", "base", ".", "APICallCloser", ")", "defaultsCommandAPI", "{", "return", "modelmanager", ".", "NewClient", "(", "caller", ")", "\n", "}", ",", "}", "\n", "defaultsCmd", ".", "newAPIRoot", "=", "defaultsCmd", ".", "NewAPIRoot", "\n", "return", "modelcmd", ".", "WrapController", "(", "defaultsCmd", ")", "\n", "}" ]

[ "NewDefaultsCommand", "wraps", "defaultsCommand", "with", "sane", "model", "settings", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "Run", "(", "ctx", "*", "cmd", ".", "Context", ")", "error", "{", "if", "err", ":=", "c", ".", "parseArgs", "(", "c", ".", "args", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "root", ",", "err", ":=", "c", ".", "newAPIRoot", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// If the user hasn't specified a cloud name,", "// use the cloud belonging to the current model", "// if we are on a supported Juju version.", "if", "c", ".", "cloudName", "==", "\"", "\"", "{", "cc", ":=", "c", ".", "newCloudAPI", "(", "root", ")", "\n", "defer", "cc", ".", "Close", "(", ")", "\n\n", "cloudTag", ",", "err", ":=", "c", ".", "maybeGetDefaultControllerCloud", "(", "cc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "c", ".", "cloudName", "=", "cloudTag", ".", "Id", "(", ")", "\n", "}", "\n\n", "client", ":=", "c", ".", "newDefaultsAPI", "(", "root", ")", "\n", "defer", "client", ".", "Close", "(", ")", "\n\n", "if", "len", "(", "c", ".", "resetKeys", ")", ">", "0", "{", "err", ":=", "c", ".", "resetDefaults", "(", "client", ",", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "// We return this error naked as it is almost certainly going to be", "// cmd.ErrSilent and the cmd.Command framework expects that back", "// from cmd.Run if the process is blocked.", "return", "err", "\n", "}", "\n", "}", "\n", "if", "c", ".", "action", "==", "nil", "{", "// If we are reset only we end up here, only we've already done that.", "return", "nil", "\n", "}", "\n", "return", "c", ".", "action", "(", "client", ",", "ctx", ")", "\n", "}" ]

[ "Run", "implements", "part", "of", "the", "cmd", ".", "Command", "interface", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "parseArgsForRegion", "(", "args", "[", "]", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "err", "error", "\n", "if", "len", "(", "args", ")", ">", "0", "{", "// determine if the first arg is cloud/region or region and return", "// appropriate positional args.", "args", ",", "err", "=", "c", ".", "parseCloudRegion", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "args", ",", "nil", "\n", "}" ]

[ "parseArgsForRegion", "parses", "args", "to", "check", "if", "the", "first", "arg", "is", "a", "region", "and", "returns", "the", "appropriate", "remaining", "args", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "validCloudRegion", "(", "cloudName", ",", "maybeRegion", "string", ")", "(", "bool", ",", "error", ")", "{", "root", ",", "err", ":=", "c", ".", "newAPIRoot", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "cc", ":=", "c", ".", "newCloudAPI", "(", "root", ")", "\n", "defer", "cc", ".", "Close", "(", ")", "\n\n", "// We have a single value - it may be a cloud or a region.", "if", "cloudName", "==", "\"", "\"", "&&", "maybeRegion", "!=", "\"", "\"", "{", "// First try and interpret as a cloud.", "maybeCloud", ":=", "maybeRegion", "\n", "if", "!", "names", ".", "IsValidCloud", "(", "maybeCloud", ")", "{", "return", "false", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "maybeCloud", ")", "\n", "}", "\n", "// Ensure that the cloud actually exists on the controller.", "cTag", ":=", "names", ".", "NewCloudTag", "(", "maybeCloud", ")", "\n", "_", ",", "err", ":=", "cc", ".", "Cloud", "(", "cTag", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", "==", "nil", "{", "c", ".", "cloudName", "=", "maybeCloud", "\n", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n\n", "var", "cTag", "names", ".", "CloudTag", "\n", "// If a cloud is not specified, use the controller", "// cloud if that's the only one, else ask the user", "// which cloud should be used.", "if", "cloudName", "==", "\"", "\"", "{", "cTag", ",", "err", "=", "c", ".", "maybeGetDefaultControllerCloud", "(", "cc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "else", "{", "if", "!", "names", ".", "IsValidCloud", "(", "cloudName", ")", "{", "return", "false", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "cloudName", ")", "\n", "}", "\n", "cTag", "=", "names", ".", "NewCloudTag", "(", "cloudName", ")", "\n", "}", "\n", "cloud", ",", "err", ":=", "cc", ".", "Cloud", "(", "cTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "isCloudRegion", ":=", "false", "\n", "for", "_", ",", "r", ":=", "range", "cloud", ".", "Regions", "{", "if", "r", ".", "Name", "==", "maybeRegion", "{", "c", ".", "cloudName", "=", "cTag", ".", "Id", "(", ")", "\n", "c", ".", "regionName", "=", "maybeRegion", "\n", "isCloudRegion", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "isCloudRegion", ",", "nil", "\n", "}" ]

[ "validCloudRegion", "checks", "that", "region", "is", "a", "valid", "region", "in", "cloud", "or", "cloud", "for", "the", "current", "model", "if", "cloud", "is", "not", "specified", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "handleSetArgs", "(", "args", "[", "]", "string", ")", "error", "{", "// We may have a config.yaml file", "_", ",", "err", ":=", "os", ".", "Stat", "(", "args", "[", "0", "]", ")", "\n", "argZeroKeyOnly", ":=", "err", "!=", "nil", "&&", "!", "strings", ".", "Contains", "(", "args", "[", "0", "]", ",", "\"", "\"", ")", "\n", "// If an invalid region was specified, the first positional arg won't have", "// an \"=\". If we see one here we know it is invalid.", "switch", "{", "case", "argZeroKeyOnly", "&&", "c", ".", "regionName", "==", "\"", "\"", "&&", "c", ".", "cloudName", "==", "\"", "\"", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "args", "[", "0", "]", ")", "\n", "case", "argZeroKeyOnly", "&&", "c", ".", "regionName", "!=", "\"", "\"", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "default", ":", "if", "err", ":=", "c", ".", "parseSetKeys", "(", "args", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "c", ".", "action", "=", "c", ".", "setDefaults", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "handleSetArgs", "parses", "args", "for", "setting", "defaults", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "parseSetKeys", "(", "args", "[", "]", "string", ")", "error", "{", "for", "_", ",", "arg", ":=", "range", "args", "{", "if", "err", ":=", "c", ".", "setOptions", ".", "Set", "(", "arg", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "parseSetKeys", "iterates", "over", "the", "args", "and", "make", "sure", "that", "the", "key", "=", "value", "pairs", "are", "valid", ".", "It", "also", "checks", "that", "the", "same", "key", "isn", "t", "also", "being", "reset", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "handleOneArg", "(", "arg", "string", ")", "error", "{", "resetSpecified", ":=", "c", ".", "resetKeys", "!=", "nil", "\n", "regionSpecified", ":=", "c", ".", "regionName", "!=", "\"", "\"", "\n\n", "if", "regionSpecified", "{", "if", "resetSpecified", "{", "// If a region was specified and reset was specified, we shouldn't have", "// an extra arg. If it had an \"=\" in it, we should have handled it", "// already.", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "resetSpecified", "{", "// It makes no sense to supply a positional arg that isn't a region if", "// we are resetting keys in a region, so we must have gotten an invalid", "// region.", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "arg", ")", "\n", "}", "\n", "// We can retrieve a value.", "c", ".", "key", "=", "arg", "\n", "c", ".", "action", "=", "c", ".", "getDefaults", "\n", "return", "nil", "\n", "}" ]

[ "handleOneArg", "handles", "the", "case", "where", "we", "have", "one", "positional", "arg", "after", "processing", "for", "a", "region", "and", "the", "reset", "flag", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "handleExtraArgs", "(", "args", "[", "]", "string", ")", "error", "{", "resetSpecified", ":=", "c", ".", "resetKeys", "!=", "nil", "\n", "regionSpecified", ":=", "c", ".", "regionName", "!=", "\"", "\"", "\n", "numArgs", ":=", "len", "(", "args", ")", "\n\n", "// if we have a key=value pair here then something is wrong because the", "// last positional arg is not one. We assume the user intended to get a", "// value after setting them.", "for", "_", ",", "arg", ":=", "range", "args", "{", "// We may have a config.yaml file", "_", ",", "err", ":=", "os", ".", "Stat", "(", "arg", ")", "\n", "if", "err", "==", "nil", "||", "strings", ".", "Contains", "(", "arg", ",", "\"", "\"", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "!", "regionSpecified", "{", "if", "resetSpecified", "{", "if", "numArgs", "==", "2", "{", "// It makes no sense to supply a positional arg that isn't a", "// region if we are resetting a region, so we must have gotten", "// an invalid region.", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "args", "[", "0", "]", ")", "\n", "}", "\n", "}", "\n", "if", "!", "resetSpecified", "{", "// If we land here it is because there are extraneous positional", "// args.", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "handleExtraArgs", "handles", "the", "case", "where", "too", "many", "args", "were", "supplied", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "getDefaults", "(", "client", "defaultsCommandAPI", ",", "ctx", "*", "cmd", ".", "Context", ")", "error", "{", "cloudName", ":=", "c", ".", "cloudName", "\n", "if", "client", ".", "BestAPIVersion", "(", ")", "<", "6", "{", "cloudName", "=", "\"", "\"", "\n", "}", "\n", "attrs", ",", "err", ":=", "client", ".", "ModelDefaults", "(", "cloudName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "valueForRegion", ":=", "func", "(", "region", "string", ",", "regions", "[", "]", "config", ".", "RegionDefaultValue", ")", "(", "config", ".", "RegionDefaultValue", ",", "bool", ")", "{", "for", "_", ",", "r", ":=", "range", "regions", "{", "if", "r", ".", "Name", "==", "region", "{", "return", "r", ",", "true", "\n", "}", "\n", "}", "\n", "return", "config", ".", "RegionDefaultValue", "{", "}", ",", "false", "\n", "}", "\n\n", "// Filter by region if necessary.", "if", "c", ".", "regionName", "!=", "\"", "\"", "{", "for", "attrName", ",", "attr", ":=", "range", "attrs", "{", "if", "regionDefault", ",", "ok", ":=", "valueForRegion", "(", "c", ".", "regionName", ",", "attr", ".", "Regions", ")", ";", "!", "ok", "{", "delete", "(", "attrs", ",", "attrName", ")", "\n", "}", "else", "{", "attrForRegion", ":=", "attr", "\n", "attrForRegion", ".", "Regions", "=", "[", "]", "config", ".", "RegionDefaultValue", "{", "regionDefault", "}", "\n", "attrs", "[", "attrName", "]", "=", "attrForRegion", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "c", ".", "key", "!=", "\"", "\"", "{", "if", "value", ",", "ok", ":=", "attrs", "[", "c", ".", "key", "]", ";", "ok", "{", "attrs", "=", "config", ".", "ModelDefaultAttributes", "{", "c", ".", "key", ":", "value", ",", "}", "\n", "}", "else", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "key", ")", "\n", "if", "c", ".", "regionName", "!=", "\"", "\"", "{", "msg", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "regionName", ")", "\n", "}", "\n", "return", "errors", ".", "New", "(", "msg", ")", "\n", "}", "\n", "}", "\n", "if", "c", ".", "regionName", "!=", "\"", "\"", "&&", "len", "(", "attrs", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "regionName", ")", ")", "\n", "}", "\n\n", "// If c.keys is empty, write out the whole lot.", "return", "c", ".", "out", ".", "Write", "(", "ctx", ",", "attrs", ")", "\n", "}" ]

[ "getDefaults", "writes", "out", "the", "value", "for", "a", "single", "key", "or", "the", "full", "tree", "of", "defaults", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "setDefaults", "(", "client", "defaultsCommandAPI", ",", "ctx", "*", "cmd", ".", "Context", ")", "error", "{", "attrs", ",", "err", ":=", "c", ".", "setOptions", ".", "ReadAttrs", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "keys", "[", "]", "string", "\n", "values", ":=", "make", "(", "attributes", ")", "\n", "for", "k", ",", "v", ":=", "range", "attrs", "{", "if", "k", "==", "config", ".", "AgentVersionKey", "{", "return", "errors", ".", "Errorf", "(", "`\"agent-version\" must be set via \"upgrade-model\"`", ")", "\n", "}", "\n", "values", "[", "k", "]", "=", "v", "\n", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n\n", "for", "_", ",", "k", ":=", "range", "c", ".", "resetKeys", "{", "if", "_", ",", "ok", ":=", "values", "[", "k", "]", ";", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "verifyKnownKeys", "(", "client", ",", "keys", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "block", ".", "ProcessBlockedError", "(", "client", ".", "SetModelDefaults", "(", "c", ".", "cloudName", ",", "c", ".", "regionName", ",", "values", ")", ",", "block", ".", "BlockChange", ")", "\n", "}" ]

[ "setDefaults", "sets", "defaults", "as", "provided", "in", "c", ".", "values", "." ]

[ "func", "(", "c", "*", "defaultsCommand", ")", "resetDefaults", "(", "client", "defaultsCommandAPI", ",", "ctx", "*", "cmd", ".", "Context", ")", "error", "{", "// ctx unused in this method.", "if", "err", ":=", "c", ".", "verifyKnownKeys", "(", "client", ",", "c", ".", "resetKeys", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "block", ".", "ProcessBlockedError", "(", "client", ".", "UnsetModelDefaults", "(", "c", ".", "cloudName", ",", "c", ".", "regionName", ",", "c", ".", "resetKeys", "...", ")", ",", "block", ".", "BlockChange", ")", "\n\n", "}" ]

[ "resetDefaults", "resets", "the", "keys", "in", "resetKeys", "." ]

[ "func", "formatDefaultConfigTabular", "(", "writer", "io", ".", "Writer", ",", "value", "interface", "{", "}", ")", "error", "{", "defaultValues", ",", "ok", ":=", "value", ".", "(", "config", ".", "ModelDefaultAttributes", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "defaultValues", ",", "value", ")", "\n", "}", "\n\n", "tw", ":=", "output", ".", "TabWriter", "(", "writer", ")", "\n", "w", ":=", "output", ".", "Wrapper", "{", "tw", "}", "\n\n", "p", ":=", "func", "(", "name", "string", ",", "value", "config", ".", "AttributeDefaultValues", ")", "{", "var", "c", ",", "d", "interface", "{", "}", "\n", "switch", "value", ".", "Default", "{", "case", "nil", ":", "d", "=", "\"", "\"", "\n", "case", "\"", "\"", ":", "d", "=", "`\"\"`", "\n", "default", ":", "d", "=", "value", ".", "Default", "\n", "}", "\n", "switch", "value", ".", "Controller", "{", "case", "nil", ":", "c", "=", "\"", "\"", "\n", "case", "\"", "\"", ":", "c", "=", "`\"\"`", "\n", "default", ":", "c", "=", "value", ".", "Controller", "\n", "}", "\n", "w", ".", "Println", "(", "name", ",", "d", ",", "c", ")", "\n", "for", "_", ",", "region", ":=", "range", "value", ".", "Regions", "{", "w", ".", "Println", "(", "\"", "\"", "+", "region", ".", "Name", ",", "region", ".", "Value", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "var", "valueNames", "[", "]", "string", "\n", "for", "name", ":=", "range", "defaultValues", "{", "valueNames", "=", "append", "(", "valueNames", ",", "name", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "valueNames", ")", "\n\n", "w", ".", "Println", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "for", "_", ",", "name", ":=", "range", "valueNames", "{", "info", ":=", "defaultValues", "[", "name", "]", "\n", "out", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "err", ":=", "cmd", ".", "FormatYaml", "(", "out", ",", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "p", "(", "name", ",", "info", ")", "\n", "}", "\n\n", "tw", ".", "Flush", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "formatConfigTabular", "writes", "a", "tabular", "summary", "of", "default", "config", "information", "." ]

[ "func", "(", "f", "*", "factory", ")", "newDeploy", "(", "kind", "Kind", ",", "charmURL", "*", "corecharm", ".", "URL", ",", "revert", ",", "resolved", "bool", ")", "(", "Operation", ",", "error", ")", "{", "if", "charmURL", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "kind", "!=", "Install", "&&", "kind", "!=", "Upgrade", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "kind", ")", "\n", "}", "\n", "return", "&", "deploy", "{", "kind", ":", "kind", ",", "charmURL", ":", "charmURL", ",", "revert", ":", "revert", ",", "resolved", ":", "resolved", ",", "callbacks", ":", "f", ".", "config", ".", "Callbacks", ",", "deployer", ":", "f", ".", "config", ".", "Deployer", ",", "abort", ":", "f", ".", "config", ".", "Abort", ",", "}", ",", "nil", "\n", "}" ]

[ "newDeploy", "is", "the", "common", "code", "for", "creating", "arbitrary", "deploy", "operations", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewInstall", "(", "charmURL", "*", "corecharm", ".", "URL", ")", "(", "Operation", ",", "error", ")", "{", "return", "f", ".", "newDeploy", "(", "Install", ",", "charmURL", ",", "false", ",", "false", ")", "\n", "}" ]

[ "NewInstall", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewUpgrade", "(", "charmURL", "*", "corecharm", ".", "URL", ")", "(", "Operation", ",", "error", ")", "{", "return", "f", ".", "newDeploy", "(", "Upgrade", ",", "charmURL", ",", "false", ",", "false", ")", "\n", "}" ]

[ "NewUpgrade", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewNoOpUpgrade", "(", "charmURL", "*", "corecharm", ".", "URL", ")", "(", "Operation", ",", "error", ")", "{", "return", "&", "skipOperation", "{", "&", "noOpUpgrade", "{", "charmURL", ":", "charmURL", "}", "}", ",", "nil", "\n", "}" ]

[ "NewNoOpUpgrade", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewRevertUpgrade", "(", "charmURL", "*", "corecharm", ".", "URL", ")", "(", "Operation", ",", "error", ")", "{", "return", "f", ".", "newDeploy", "(", "Upgrade", ",", "charmURL", ",", "true", ",", "false", ")", "\n", "}" ]

[ "NewRevertUpgrade", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewRunHook", "(", "hookInfo", "hook", ".", "Info", ")", "(", "Operation", ",", "error", ")", "{", "if", "err", ":=", "hookInfo", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "runHook", "{", "info", ":", "hookInfo", ",", "callbacks", ":", "f", ".", "config", ".", "Callbacks", ",", "runnerFactory", ":", "f", ".", "config", ".", "RunnerFactory", ",", "}", ",", "nil", "\n", "}" ]

[ "NewRunHook", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewSkipHook", "(", "hookInfo", "hook", ".", "Info", ")", "(", "Operation", ",", "error", ")", "{", "hookOp", ",", "err", ":=", "f", ".", "NewRunHook", "(", "hookInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "skipOperation", "{", "hookOp", "}", ",", "nil", "\n", "}" ]

[ "NewSkipHook", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewAction", "(", "actionId", "string", ")", "(", "Operation", ",", "error", ")", "{", "if", "!", "names", ".", "IsValidAction", "(", "actionId", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "actionId", ")", "\n", "}", "\n", "return", "&", "runAction", "{", "actionId", ":", "actionId", ",", "callbacks", ":", "f", ".", "config", ".", "Callbacks", ",", "runnerFactory", ":", "f", ".", "config", ".", "RunnerFactory", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAction", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewFailAction", "(", "actionId", "string", ")", "(", "Operation", ",", "error", ")", "{", "if", "!", "names", ".", "IsValidAction", "(", "actionId", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "actionId", ")", "\n", "}", "\n", "return", "&", "failAction", "{", "actionId", ":", "actionId", ",", "callbacks", ":", "f", ".", "config", ".", "Callbacks", ",", "}", ",", "nil", "\n", "}" ]

[ "NewFailAction", "is", "part", "of", "the", "factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewCommands", "(", "args", "CommandArgs", ",", "sendResponse", "CommandResponseFunc", ")", "(", "Operation", ",", "error", ")", "{", "if", "args", ".", "Commands", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "sendResponse", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "args", ".", "RemoteUnitName", "!=", "\"", "\"", "{", "if", "args", ".", "RelationId", "==", "-", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "!", "names", ".", "IsValidUnit", "(", "args", ".", "RemoteUnitName", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "args", ".", "RemoteUnitName", ")", "\n", "}", "\n", "}", "\n", "return", "&", "runCommands", "{", "args", ":", "args", ",", "sendResponse", ":", "sendResponse", ",", "callbacks", ":", "f", ".", "config", ".", "Callbacks", ",", "runnerFactory", ":", "f", ".", "config", ".", "RunnerFactory", ",", "}", ",", "nil", "\n", "}" ]

[ "NewCommands", "is", "part", "of", "the", "Factory", "interface", "." ]

[ "func", "APIWorkersManifold", "(", "config", "APIWorkersConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "APICallerName", ",", "}", ",", "Start", ":", "func", "(", "context", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "if", "config", ".", "StartAPIWorkers", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Get API connection.", "var", "apiConn", "api", ".", "Connection", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "APICallerName", ",", "&", "apiConn", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "config", ".", "StartAPIWorkers", "(", "apiConn", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "APIWorkersManifold", "starts", "workers", "that", "rely", "on", "an", "API", "connection", "using", "a", "function", "provided", "to", "it", ".", "This", "manifold", "exists", "to", "start", "API", "workers", "which", "have", "not", "yet", "been", "ported", "to", "work", "directly", "with", "the", "dependency", "engine", ".", "Once", "all", "API", "workers", "started", "by", "StartAPIWorkers", "have", "been", "migrated", "to", "the", "dependency", "engine", "this", "manifold", "can", "be", "removed", "." ]

[ "func", "recursiveChmod", "(", "path", "string", ",", "mode", "os", ".", "FileMode", ")", "error", "{", "walker", ":=", "func", "(", "p", "string", ",", "fi", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "p", ")", ";", "err", "==", "nil", "{", "errPerm", ":=", "os", ".", "Chmod", "(", "p", ",", "mode", ")", "\n", "if", "errPerm", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "errPerm", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "filepath", ".", "Walk", "(", "path", ",", "walker", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "recursiveChmod", "will", "change", "the", "permissions", "on", "all", "files", "and", "folders", "inside", "path" ]

[ "func", "NewSimpleContext", "(", "agentConfig", "agent", ".", "Config", ",", "api", "APICalls", ")", "*", "SimpleContext", "{", "return", "&", "SimpleContext", "{", "api", ":", "api", ",", "agentConfig", ":", "agentConfig", ",", "discoverService", ":", "func", "(", "name", "string", ",", "conf", "common", ".", "Conf", ")", "(", "deployerService", ",", "error", ")", "{", "return", "service", ".", "DiscoverService", "(", "name", ",", "conf", ")", "\n", "}", ",", "listServices", ":", "func", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "service", ".", "ListServices", "(", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewSimpleContext", "returns", "a", "new", "SimpleContext", "acting", "on", "behalf", "of", "the", "specified", "deployer", "that", "deploys", "unit", "agents", ".", "Paths", "to", "which", "agents", "and", "tools", "are", "installed", "are", "relative", "to", "dataDir", "." ]

[ "func", "(", "ctx", "*", "SimpleContext", ")", "service", "(", "unitName", "string", ",", "renderer", "shell", ".", "Renderer", ")", "(", "deployerService", ",", "error", ")", "{", "// Service name can be at most 64 characters long, we limit it to 56 just to be safe.", "tag", ",", "err", ":=", "names", ".", "NewUnitTag", "(", "unitName", ")", ".", "ShortenedString", "(", "56", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "svcName", ":=", "\"", "\"", "+", "tag", "\n\n", "info", ":=", "service", ".", "NewAgentInfo", "(", "service", ".", "AgentKindUnit", ",", "unitName", ",", "ctx", ".", "agentConfig", ".", "DataDir", "(", ")", ",", "ctx", ".", "agentConfig", ".", "LogDir", "(", ")", ",", ")", "\n\n", "// TODO(thumper): 2013-09-02 bug 1219630", "// As much as I'd like to remove JujuContainerType now, it is still", "// needed as MAAS still needs it at this stage, and we can't fix", "// everything at once.", "containerType", ":=", "ctx", ".", "agentConfig", ".", "Value", "(", "agent", ".", "ContainerType", ")", "\n\n", "conf", ":=", "service", ".", "ContainerAgentConf", "(", "info", ",", "renderer", ",", "containerType", ")", "\n", "return", "ctx", ".", "discoverService", "(", "svcName", ",", "conf", ")", "\n", "}" ]

[ "service", "returns", "a", "service", ".", "Service", "corresponding", "to", "the", "specified", "unit", "." ]

[ "func", "(", "st", "*", "State", ")", "GUISetVersion", "(", "vers", "version", ".", "Number", ")", "error", "{", "// Check that the provided version is actually present in the GUI storage.", "storage", ",", "err", ":=", "st", ".", "GUIStorage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "storage", ".", "Close", "(", ")", "\n", "if", "_", ",", "err", "=", "storage", ".", "Metadata", "(", "vers", ".", "String", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "vers", ")", "\n", "}", "\n\n", "// Set the current version.", "settings", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "guisettingsC", ")", "\n", "defer", "closer", "(", ")", "\n", "if", "_", ",", "err", "=", "settings", ".", "Writeable", "(", ")", ".", "Upsert", "(", "nil", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "vers", "}", "}", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GUISetVersion", "sets", "the", "Juju", "GUI", "version", "that", "the", "controller", "must", "serve", "." ]

[ "func", "(", "st", "*", "State", ")", "GUIVersion", "(", ")", "(", "vers", "version", ".", "Number", ",", "err", "error", ")", "{", "settings", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "guisettingsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "// Retrieve the settings document.", "var", "doc", "guiSettingsDoc", "\n", "err", "=", "settings", ".", "Find", "(", "nil", ")", ".", "Select", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "==", "nil", "{", "return", "doc", ".", "CurrentVersion", ",", "nil", "\n", "}", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "vers", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "vers", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "GUIVersion", "returns", "the", "Juju", "GUI", "version", "currently", "served", "by", "the", "controller", "." ]

[ "func", "NewFacade", "(", "caller", "base", ".", "APICaller", ")", "*", "Facade", "{", "return", "&", "Facade", "{", "caller", ":", "base", ".", "NewFacadeCaller", "(", "caller", ",", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "NewFacade", "creates", "a", "new", "client", "-", "side", "FanConfigu", "er", "facade", "." ]

[ "func", "(", "f", "*", "Facade", ")", "WatchForFanConfigChanges", "(", ")", "(", "watcher", ".", "NotifyWatcher", ",", "error", ")", "{", "var", "result", "params", ".", "NotifyWatchResult", "\n", "err", ":=", "f", ".", "caller", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "apiwatcher", ".", "NewNotifyWatcher", "(", "f", ".", "caller", ".", "RawAPICaller", "(", ")", ",", "result", ")", ",", "nil", "\n", "}" ]

[ "WatchForFanConfigChanges", "return", "a", "NotifyWatcher", "waiting", "for", "the", "fan", "configuration", "to", "change", "." ]

[ "func", "(", "f", "*", "Facade", ")", "FanConfig", "(", ")", "(", "network", ".", "FanConfig", ",", "error", ")", "{", "var", "result", "params", ".", "FanConfigResult", "\n", "err", ":=", "f", ".", "caller", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "networkingcommon", ".", "FanConfigResultToFanConfig", "(", "result", ")", "\n", "}" ]

[ "FanConfig", "returns", "the", "current", "fan", "configuration", "." ]

[ "func", "(", "kw", "*", "keyupdaterWorker", ")", "Handle", "(", "_", "<-", "chan", "struct", "{", "}", ")", "error", "{", "// Read the keys that Juju has.", "newKeys", ",", "err", ":=", "kw", ".", "st", ".", "AuthorisedKeys", "(", "kw", ".", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "kw", ".", "tag", ")", "\n", "logger", ".", "Infof", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "err", "\n", "}", "\n", "// Figure out if any keys have been added or deleted.", "newJujuKeys", ":=", "set", ".", "NewStrings", "(", "newKeys", "...", ")", "\n", "deleted", ":=", "kw", ".", "jujuKeys", ".", "Difference", "(", "newJujuKeys", ")", "\n", "added", ":=", "newJujuKeys", ".", "Difference", "(", "kw", ".", "jujuKeys", ")", "\n", "if", "added", ".", "Size", "(", ")", ">", "0", "||", "deleted", ".", "Size", "(", ")", ">", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "added", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "deleted", ")", "\n", "if", "err", "=", "kw", ".", "writeSSHKeys", "(", "newKeys", ")", ";", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "logger", ".", "Infof", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "kw", ".", "jujuKeys", "=", "newJujuKeys", "\n", "return", "nil", "\n", "}" ]

[ "Handle", "is", "defined", "on", "the", "worker", ".", "NotifyWatchHandler", "interface", "." ]

[ "func", "parseList", "(", "list", "[", "]", "params", ".", "BackupsMetadataResult", ")", "(", "[", "]", "string", ",", "string", ",", "error", ")", "{", "if", "len", "(", "list", ")", "==", "0", "{", "return", "nil", ",", "\"", "\"", ",", "nil", "\n", "}", "\n", "latest", ":=", "list", "[", "0", "]", "\n", "retList", ":=", "set", ".", "NewStrings", "(", ")", "\n", "// Start looking for a new latest with the 2nd item in the slice.", "for", "_", ",", "entry", ":=", "range", "list", "[", "1", ":", "]", "{", "if", "entry", ".", "Started", ".", "After", "(", "latest", ".", "Started", ")", "{", "// Found a new latest, add the old one to the set", "retList", ".", "Add", "(", "latest", ".", "ID", ")", "\n", "latest", "=", "entry", "\n", "continue", "\n", "}", "\n", "// Not the latest, add to the set", "retList", ".", "Add", "(", "entry", ".", "ID", ")", "\n", "}", "\n", "return", "retList", ".", "SortedValues", "(", ")", ",", "latest", ".", "ID", ",", "nil", "\n", "}" ]

[ "parseList", "returns", "a", "list", "of", "IDs", "to", "be", "removed", "and", "the", "one", "ID", "to", "be", "kept", ".", "Keep", "the", "latest", "ID", "based", "on", "Started", "." ]

[ "func", "(", "c", "*", "collectMetricsCommand", ")", "Init", "(", "args", "[", "]", "string", ")", "error", "{", "if", "len", "(", "args", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "c", ".", "entity", "=", "args", "[", "0", "]", "\n", "if", "names", ".", "IsValidUnit", "(", "c", ".", "entity", ")", "{", "c", ".", "unit", "=", "c", ".", "entity", "\n", "}", "else", "if", "names", ".", "IsValidApplication", "(", "args", "[", "0", "]", ")", "{", "c", ".", "application", "=", "c", ".", "entity", "\n", "}", "else", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "args", "[", "0", "]", ")", "\n", "}", "\n", "if", "err", ":=", "cmd", ".", "CheckEmpty", "(", "args", "[", "1", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", "+", "strings", ".", "Join", "(", "args", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Init", "reads", "and", "verifies", "the", "cli", "arguments", "for", "the", "collectMetricsCommand" ]