Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.3k

[ "func", "NewFacadeV4", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "MachineManagerAPIV4", ",", "error", ")", "{", "machineManagerAPIV5", ",", "err", ":=", "NewFacadeV5", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "MachineManagerAPIV4", "{", "machineManagerAPIV5", "}", ",", "nil", "\n", "}" ]

[ "NewFacadeV4", "creates", "a", "new", "server", "-", "side", "MachineManager", "API", "facade", "." ]

[ "func", "NewFacadeV5", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "MachineManagerAPIV5", ",", "error", ")", "{", "machineManagerAPIv6", ",", "err", ":=", "NewFacadeV6", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "MachineManagerAPIV5", "{", "machineManagerAPIv6", "}", ",", "nil", "\n", "}" ]

[ "NewFacadeV5", "creates", "a", "new", "server", "-", "side", "MachineManager", "API", "facade", "." ]

[ "func", "NewFacadeV6", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "MachineManagerAPIV6", ",", "error", ")", "{", "machineManagerAPI", ",", "err", ":=", "NewFacade", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "MachineManagerAPIV6", "{", "machineManagerAPI", "}", ",", "nil", "\n", "}" ]

[ "NewFacadeV6", "creates", "a", "new", "server", "-", "side", "MachineManager", "API", "facade", "." ]

[ "func", "NewMachineManagerAPI", "(", "backend", "Backend", ",", "storageAccess", "storageInterface", ",", "pool", "Pool", ",", "auth", "facade", ".", "Authorizer", ",", "modelTag", "names", ".", "ModelTag", ",", "callCtx", "context", ".", "ProviderCallContext", ",", "resources", "facade", ".", "Resources", ",", ")", "(", "*", "MachineManagerAPI", ",", "error", ")", "{", "if", "!", "auth", ".", "AuthClient", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "&", "MachineManagerAPI", "{", "st", ":", "backend", ",", "storageAccess", ":", "storageAccess", ",", "pool", ":", "pool", ",", "authorizer", ":", "auth", ",", "check", ":", "common", ".", "NewBlockChecker", "(", "backend", ")", ",", "modelTag", ":", "modelTag", ",", "callContext", ":", "callCtx", ",", "resources", ":", "resources", ",", "}", ",", "nil", "\n", "}" ]

[ "NewMachineManagerAPI", "creates", "a", "new", "server", "-", "side", "MachineManager", "API", "facade", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "DestroyMachine", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "DestroyMachineResults", ",", "error", ")", "{", "return", "mm", ".", "destroyMachine", "(", "args", ",", "false", ",", "false", ",", "time", ".", "Duration", "(", "0", ")", ")", "\n", "}" ]

[ "DestroyMachine", "removes", "a", "set", "of", "machines", "from", "the", "model", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPIV5", ")", "DestroyMachineWithParams", "(", "args", "params", ".", "DestroyMachinesParams", ")", "(", "params", ".", "DestroyMachineResults", ",", "error", ")", "{", "entities", ":=", "params", ".", "Entities", "{", "Entities", ":", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "args", ".", "MachineTags", ")", ")", "}", "\n", "for", "i", ",", "tag", ":=", "range", "args", ".", "MachineTags", "{", "entities", ".", "Entities", "[", "i", "]", ".", "Tag", "=", "tag", "\n", "}", "\n", "return", "mm", ".", "destroyMachine", "(", "entities", ",", "args", ".", "Force", ",", "args", ".", "Keep", ",", "time", ".", "Duration", "(", "0", ")", ")", "\n", "}" ]

[ "DestroyMachineWithParams", "removes", "a", "set", "of", "machines", "from", "the", "model", ".", "v5", "and", "prior", "versions", "did", "not", "support", "MaxWait", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "DestroyMachineWithParams", "(", "args", "params", ".", "DestroyMachinesParams", ")", "(", "params", ".", "DestroyMachineResults", ",", "error", ")", "{", "entities", ":=", "params", ".", "Entities", "{", "Entities", ":", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "args", ".", "MachineTags", ")", ")", "}", "\n", "for", "i", ",", "tag", ":=", "range", "args", ".", "MachineTags", "{", "entities", ".", "Entities", "[", "i", "]", ".", "Tag", "=", "tag", "\n", "}", "\n", "return", "mm", ".", "destroyMachine", "(", "entities", ",", "args", ".", "Force", ",", "args", ".", "Keep", ",", "common", ".", "MaxWait", "(", "args", ".", "MaxWait", ")", ")", "\n", "}" ]

[ "DestroyMachineWithParams", "removes", "a", "set", "of", "machines", "from", "the", "model", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "UpgradeSeriesValidate", "(", "args", "params", ".", "UpdateSeriesArgs", ",", ")", "(", "params", ".", "UpgradeSeriesUnitsResults", ",", "error", ")", "{", "err", ":=", "mm", ".", "checkCanRead", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "UpgradeSeriesUnitsResults", "{", "}", ",", "err", "\n", "}", "\n\n", "results", ":=", "make", "(", "[", "]", "params", ".", "UpgradeSeriesUnitsResult", ",", "len", "(", "args", ".", "Args", ")", ")", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Args", "{", "tag", ":=", "arg", ".", "Entity", ".", "Tag", "\n", "machine", ",", "err", ":=", "mm", ".", "machineFromTag", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "if", "machine", ".", "IsManager", "(", ")", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "errors", ".", "Errorf", "(", "\"", "\"", ",", "tag", ")", ")", "\n", "continue", "\n", "}", "\n\n", "err", "=", "mm", ".", "validateSeries", "(", "arg", ".", "Series", ",", "machine", ".", "Series", "(", ")", ",", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "unitNames", ",", "err", ":=", "mm", ".", "verifiedUnits", "(", "machine", ",", "arg", ".", "Series", ",", "arg", ".", "Force", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", "[", "i", "]", ".", "UnitNames", "=", "unitNames", "\n", "}", "\n\n", "return", "params", ".", "UpgradeSeriesUnitsResults", "{", "Results", ":", "results", "}", ",", "nil", "\n", "}" ]

[ "UpgradeSeriesValidate", "validates", "that", "the", "incoming", "arguments", "correspond", "to", "a", "valid", "series", "upgrade", "for", "the", "target", "machine", ".", "If", "they", "do", "a", "list", "of", "the", "machine", "s", "current", "units", "is", "returned", "for", "use", "in", "soliciting", "user", "confirmation", "of", "the", "command", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "UpgradeSeriesPrepare", "(", "args", "params", ".", "UpdateSeriesArg", ")", "(", "params", ".", "ErrorResult", ",", "error", ")", "{", "if", "err", ":=", "mm", ".", "checkCanWrite", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "}", ",", "err", "\n", "}", "\n", "if", "err", ":=", "mm", ".", "check", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "}", ",", "err", "\n", "}", "\n", "err", ":=", "mm", ".", "upgradeSeriesPrepare", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "Error", ":", "common", ".", "ServerError", "(", "err", ")", "}", ",", "nil", "\n", "}", "\n", "return", "params", ".", "ErrorResult", "{", "}", ",", "nil", "\n", "}" ]

[ "UpgradeSeriesPrepare", "prepares", "a", "machine", "for", "a", "OS", "series", "upgrade", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "UpgradeSeriesComplete", "(", "args", "params", ".", "UpdateSeriesArg", ")", "(", "params", ".", "ErrorResult", ",", "error", ")", "{", "if", "err", ":=", "mm", ".", "checkCanWrite", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "}", ",", "err", "\n", "}", "\n", "if", "err", ":=", "mm", ".", "check", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "}", ",", "err", "\n", "}", "\n", "if", "err", ":=", "mm", ".", "check", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "}", ",", "err", "\n", "}", "\n", "err", ":=", "mm", ".", "completeUpgradeSeries", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "Error", ":", "common", ".", "ServerError", "(", "err", ")", "}", ",", "nil", "\n", "}", "\n\n", "return", "params", ".", "ErrorResult", "{", "}", ",", "nil", "\n", "}" ]

[ "UpgradeSeriesComplete", "marks", "a", "machine", "as", "having", "completed", "a", "managed", "series", "upgrade", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "WatchUpgradeSeriesNotifications", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "NotifyWatchResults", ",", "error", ")", "{", "err", ":=", "mm", ".", "checkCanRead", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "NotifyWatchResults", "{", "}", ",", "err", "\n", "}", "\n", "result", ":=", "params", ".", "NotifyWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "NotifyWatchResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "common", ".", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n", "watcherId", ":=", "\"", "\"", "\n", "machine", ",", "err", ":=", "mm", ".", "st", ".", "Machine", "(", "tag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "w", ",", "err", ":=", "machine", ".", "WatchUpgradeSeriesNotifications", "(", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "watcherId", "=", "mm", ".", "resources", ".", "Register", "(", "w", ")", "\n", "result", ".", "Results", "[", "i", "]", ".", "NotifyWatcherId", "=", "watcherId", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "WatchUpgradeSeriesNotifications", "returns", "a", "watcher", "that", "fires", "on", "upgrade", "series", "events", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "GetUpgradeSeriesMessages", "(", "args", "params", ".", "UpgradeSeriesNotificationParams", ")", "(", "params", ".", "StringsResults", ",", "error", ")", "{", "if", "err", ":=", "mm", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "StringsResults", "{", "}", ",", "err", "\n", "}", "\n", "results", ":=", "params", ".", "StringsResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "StringsResult", ",", "len", "(", "args", ".", "Params", ")", ")", ",", "}", "\n", "for", "i", ",", "param", ":=", "range", "args", ".", "Params", "{", "machine", ",", "err", ":=", "mm", ".", "machineFromTag", "(", "param", ".", "Entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Trace", "(", "err", ")", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "messages", ",", "finished", ",", "err", ":=", "machine", ".", "GetUpgradeSeriesMessages", "(", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "finished", "{", "// If there are no more messages we stop the watcher resource.", "err", "=", "mm", ".", "resources", ".", "Stop", "(", "param", ".", "WatcherId", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Result", "=", "messages", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "GetUpgradeSeriesMessages", "returns", "all", "new", "messages", "associated", "with", "upgrade", "series", "events", ".", "Messages", "that", "have", "already", "been", "retrieved", "once", "are", "not", "returned", "by", "this", "method", "." ]

[ "func", "(", "mm", "*", "MachineManagerAPI", ")", "verifiedUnits", "(", "machine", "Machine", ",", "series", "string", ",", "force", "bool", ")", "(", "[", "]", "string", ",", "error", ")", "{", "principals", ":=", "machine", ".", "Principals", "(", ")", "\n", "units", ",", "err", ":=", "machine", ".", "VerifyUnitsSeries", "(", "principals", ",", "series", ",", "force", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "unitNames", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "units", ")", ")", "\n", "for", "i", ",", "u", ":=", "range", "units", "{", "agentStatus", ",", "err", ":=", "u", ".", "AgentStatus", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "agentStatus", ".", "Status", "!=", "status", ".", "Idle", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "u", ".", "Name", "(", ")", ",", "agentStatus", ".", "Status", ",", "agentStatus", ".", "Message", ")", "\n", "}", "\n", "unitStatus", ",", "err", ":=", "u", ".", "Status", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "unitStatus", ".", "Status", "==", "status", ".", "Error", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "u", ".", "Name", "(", ")", ",", "unitStatus", ".", "Message", ")", "\n", "}", "\n\n", "unitNames", "[", "i", "]", "=", "u", ".", "UnitTag", "(", ")", ".", "Id", "(", ")", "\n", "}", "\n", "return", "unitNames", ",", "nil", "\n", "}" ]

[ "verifiedUnits", "verifies", "that", "the", "machine", "units", "and", "their", "tree", "of", "subordinates", "all", "support", "the", "input", "series", ".", "If", "not", "an", "error", "is", "returned", ".", "If", "they", "do", "the", "agent", "statuses", "are", "checked", "to", "ensure", "that", "they", "are", "all", "in", "the", "idle", "state", "i", ".", "e", ".", "not", "installing", "running", "hooks", "or", "needing", "intervention", ".", "the", "final", "check", "is", "that", "the", "unit", "itself", "is", "not", "in", "an", "error", "state", "." ]

[ "func", "isSeriesLessThan", "(", "series1", ",", "series2", "string", ")", "(", "bool", ",", "error", ")", "{", "version1", ",", "err", ":=", "series", ".", "SeriesVersion", "(", "series1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "version2", ",", "err", ":=", "series", ".", "SeriesVersion", "(", "series2", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "version2", ">", "version1", ",", "nil", "\n", "}" ]

[ "isSeriesLessThan", "returns", "a", "bool", "indicating", "whether", "the", "first", "argument", "s", "version", "is", "lexicographically", "less", "than", "the", "second", "argument", "s", "thus", "indicating", "that", "the", "series", "represents", "an", "older", "version", "of", "the", "operating", "system", ".", "The", "output", "is", "only", "valid", "for", "Ubuntu", "series", "." ]

[ "func", "ClientScript", "(", "c", "*", "HooksContext", ",", "match", "[", "]", "string", ")", "string", "{", "// If any argument is \"*\", then the client is interested in all.", "for", "_", ",", "m", ":=", "range", "match", "{", "if", "m", "==", "\"", "\"", "{", "match", "=", "nil", "\n", "break", "\n", "}", "\n", "}", "\n\n", "s", ":=", "strings", ".", "Replace", "(", "debugHooksClientScript", ",", "\"", "\"", ",", "c", ".", "Unit", ",", "-", "1", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "tmuxConf", ",", "1", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "c", ".", "ClientFileLock", "(", ")", ",", "-", "1", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "c", ".", "ClientExitFileLock", "(", ")", ",", "-", "1", ")", "\n\n", "yamlArgs", ":=", "encodeArgs", "(", "match", ")", "\n", "base64Args", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "yamlArgs", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "base64Args", ",", "1", ")", "\n", "return", "s", "\n", "}" ]

[ "ClientScript", "returns", "a", "bash", "script", "suitable", "for", "executing", "on", "the", "unit", "system", "to", "intercept", "matching", "hooks", "or", "actions", "via", "tmux", "shell", "." ]

[ "func", "Manifold", "(", "a", "agent", ".", "Agent", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Start", ":", "startFunc", "(", "a", ")", ",", "Output", ":", "outputFunc", ",", "}", "\n", "}" ]

[ "Manifold", "returns", "a", "manifold", "that", "starts", "a", "worker", "proxying", "the", "supplied", "Agent", "for", "use", "by", "other", "workers", "." ]

[ "func", "startFunc", "(", "a", "agent", ".", "Agent", ")", "dependency", ".", "StartFunc", "{", "return", "func", "(", "_", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "w", ":=", "&", "agentWorker", "{", "agent", ":", "a", "}", "\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "<-", "w", ".", "tomb", ".", "Dying", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "w", ",", "nil", "\n", "}", "\n", "}" ]

[ "startFunc", "returns", "a", "StartFunc", "that", "starts", "a", "worker", "holding", "a", "reference", "to", "the", "supplied", "Agent", "." ]

[ "func", "New", "(", "m", "*", "machiner", ".", "State", ",", "agent", "Agent", ")", "watcher", ".", "NotifyHandler", "{", "return", "&", "converter", "{", "machiner", ":", "wrapper", "{", "m", "}", ",", "agent", ":", "agent", "}", "\n", "}" ]

[ "New", "returns", "a", "new", "notify", "watch", "handler", "that", "will", "convert", "the", "given", "machine", "&", "agent", "to", "a", "controller", "." ]

[ "func", "(", "c", "*", "converter", ")", "SetUp", "(", ")", "(", "watcher", ".", "NotifyWatcher", ",", "error", ")", "{", "m", ",", "err", ":=", "c", ".", "machiner", ".", "Machine", "(", "c", ".", "agent", ".", "Tag", "(", ")", ".", "(", "names", ".", "MachineTag", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "c", ".", "machine", "=", "m", "\n", "return", "m", ".", "Watch", "(", ")", "\n", "}" ]

[ "SetUp", "implements", "NotifyWatchHandler", "s", "SetUp", "method", ".", "It", "returns", "a", "watcher", "that", "checks", "for", "changes", "to", "the", "current", "machine", "." ]

[ "func", "(", "c", "*", "converter", ")", "Handle", "(", "_", "<-", "chan", "struct", "{", "}", ")", "error", "{", "results", ",", "err", ":=", "c", ".", "machine", ".", "Jobs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "multiwatcher", ".", "AnyJobNeedsState", "(", "results", ".", "Jobs", "...", ")", "{", "return", "nil", "\n", "}", "\n\n", "return", "&", "util", ".", "FatalError", "{", "\"", "\"", "}", "\n", "}" ]

[ "Handle", "implements", "NotifyWatchHandler", "s", "Handle", "method", ".", "If", "the", "change", "means", "that", "the", "machine", "is", "now", "expected", "to", "manage", "the", "environment", "we", "throw", "a", "fatal", "error", "to", "instigate", "agent", "restart", "." ]

[ "func", "NewState", "(", "caller", "base", ".", "APICaller", ",", "machineTag", "names", ".", "MachineTag", ")", "State", "{", "return", "&", "state", "{", "facade", ":", "base", ".", "NewFacadeCaller", "(", "caller", ",", "\"", "\"", ")", ",", "machineTag", ":", "machineTag", ",", "}", "\n", "}" ]

[ "NewState", "returns", "a", "version", "of", "the", "state", "that", "provides", "functionality", "required", "by", "the", "reboot", "worker", "." ]

[ "func", "(", "st", "*", "state", ")", "WatchForRebootEvent", "(", ")", "(", "watcher", ".", "NotifyWatcher", ",", "error", ")", "{", "var", "result", "params", ".", "NotifyWatchResult", "\n\n", "if", "err", ":=", "st", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n\n", "w", ":=", "apiwatcher", ".", "NewNotifyWatcher", "(", "st", ".", "facade", ".", "RawAPICaller", "(", ")", ",", "result", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "WatchForRebootEvent", "implements", "State", ".", "WatchForRebootEvent" ]

[ "func", "(", "st", "*", "state", ")", "RequestReboot", "(", ")", "error", "{", "var", "results", "params", ".", "ErrorResults", "\n", "args", ":=", "params", ".", "Entities", "{", "Entities", ":", "[", "]", "params", ".", "Entity", "{", "{", "Tag", ":", "st", ".", "machineTag", ".", "String", "(", ")", "}", "}", ",", "}", "\n\n", "err", ":=", "st", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n\n", "if", "results", ".", "Results", "[", "0", "]", ".", "Error", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "results", ".", "Results", "[", "0", "]", ".", "Error", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RequestReboot", "implements", "State", ".", "RequestReboot" ]

[ "func", "(", "st", "*", "state", ")", "GetRebootAction", "(", ")", "(", "params", ".", "RebootAction", ",", "error", ")", "{", "var", "results", "params", ".", "RebootActionResults", "\n", "args", ":=", "params", ".", "Entities", "{", "Entities", ":", "[", "]", "params", ".", "Entity", "{", "{", "Tag", ":", "st", ".", "machineTag", ".", "String", "(", ")", "}", "}", ",", "}", "\n\n", "err", ":=", "st", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ShouldDoNothing", ",", "err", "\n", "}", "\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "params", ".", "ShouldDoNothing", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n\n", "if", "results", ".", "Results", "[", "0", "]", ".", "Error", "!=", "nil", "{", "return", "params", ".", "ShouldDoNothing", ",", "errors", ".", "Trace", "(", "results", ".", "Results", "[", "0", "]", ".", "Error", ")", "\n", "}", "\n\n", "return", "results", ".", "Results", "[", "0", "]", ".", "Result", ",", "nil", "\n", "}" ]

[ "GetRebootAction", "implements", "State", ".", "GetRebootAction" ]

[ "func", "IsFortressError", "(", "err", "error", ")", "bool", "{", "switch", "errors", ".", "Cause", "(", "err", ")", "{", "case", "ErrAborted", ",", "ErrShutdown", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsFortressError", "returns", "true", "if", "the", "error", "provided", "is", "fortress", "related", "." ]

[ "func", "bestVersion", "(", "desiredVersion", "int", ",", "versions", "[", "]", "int", ")", "int", "{", "best", ":=", "0", "\n", "for", "_", ",", "version", ":=", "range", "versions", "{", "if", "version", "<=", "desiredVersion", "&&", "version", ">", "best", "{", "best", "=", "version", "\n", "}", "\n", "}", "\n", "return", "best", "\n", "}" ]

[ "bestVersion", "tries", "to", "find", "the", "newest", "version", "in", "the", "version", "list", "that", "we", "can", "use", "." ]

[ "func", "NewLeadershipSettingsAccessor", "(", "authorizer", "facade", ".", "Authorizer", ",", "registerWatcherFn", "RegisterWatcherFn", ",", "getSettingsFn", "GetSettingsFn", ",", "leaderCheckFn", "LeaderCheckFn", ",", "mergeSettingsChunkFn", "MergeSettingsChunkFn", ",", ")", "*", "LeadershipSettingsAccessor", "{", "return", "&", "LeadershipSettingsAccessor", "{", "authorizer", ":", "authorizer", ",", "registerWatcherFn", ":", "registerWatcherFn", ",", "getSettingsFn", ":", "getSettingsFn", ",", "leaderCheckFn", ":", "leaderCheckFn", ",", "mergeSettingsChunkFn", ":", "mergeSettingsChunkFn", ",", "}", "\n", "}" ]

[ "NewLeadershipSettingsAccessor", "creates", "a", "new", "LeadershipSettingsAccessor", "." ]

[ "func", "(", "lsa", "*", "LeadershipSettingsAccessor", ")", "Merge", "(", "bulkArgs", "params", ".", "MergeLeadershipSettingsBulkParams", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "requireAppName", ",", "err", ":=", "lsa", ".", "callerApplication", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResults", "{", "}", ",", "err", "\n", "}", "\n", "// Start out assuming the caller is a unit (for older clients).", "callerUnitId", ":=", "lsa", ".", "authorizer", ".", "GetAuthTag", "(", ")", ".", "Id", "(", ")", "\n\n", "results", ":=", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "bulkArgs", ".", "Params", ")", ")", "\n\n", "for", "i", ",", "arg", ":=", "range", "bulkArgs", ".", "Params", "{", "result", ":=", "&", "results", "[", "i", "]", "\n\n", "// TODO(fwereade): we shoudn't assume a ApplicationTag: we should", "// use an actual auth func to determine permissions.", "applicationTag", ",", "err", ":=", "names", ".", "ParseApplicationTag", "(", "arg", ".", "ApplicationTag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "// If a unit is passed in as an arg, use that instead of the caller id.", "if", "arg", ".", "UnitTag", "!=", "\"", "\"", "{", "unitTag", ",", "err", ":=", "names", ".", "ParseUnitTag", "(", "arg", ".", "UnitTag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "callerUnitId", "=", "unitTag", ".", "Id", "(", ")", "\n", "unitAppName", ",", "err", ":=", "names", ".", "UnitApplication", "(", "callerUnitId", ")", "\n", "if", "err", "!=", "nil", "||", "unitAppName", "!=", "requireAppName", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "common", ".", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n", "}", "\n\n", "appName", ":=", "applicationTag", ".", "Id", "(", ")", "\n", "if", "appName", "!=", "requireAppName", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "common", ".", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n\n", "token", ":=", "lsa", ".", "leaderCheckFn", "(", "appName", ",", "callerUnitId", ")", "\n", "err", "=", "lsa", ".", "mergeSettingsChunkFn", "(", "token", ",", "appName", ",", "arg", ".", "Settings", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "params", ".", "ErrorResults", "{", "Results", ":", "results", "}", ",", "nil", "\n", "}" ]

[ "Merge", "merges", "in", "the", "provided", "leadership", "settings", ".", "Only", "leaders", "for", "the", "given", "service", "may", "perform", "this", "operation", "." ]

[ "func", "(", "lsa", "*", "LeadershipSettingsAccessor", ")", "Read", "(", "bulkArgs", "params", ".", "Entities", ")", "(", "params", ".", "GetLeadershipSettingsBulkResults", ",", "error", ")", "{", "requireAppName", ",", "err", ":=", "lsa", ".", "callerApplication", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "GetLeadershipSettingsBulkResults", "{", "}", ",", "err", "\n", "}", "\n", "results", ":=", "make", "(", "[", "]", "params", ".", "GetLeadershipSettingsResult", ",", "len", "(", "bulkArgs", ".", "Entities", ")", ")", "\n\n", "for", "i", ",", "arg", ":=", "range", "bulkArgs", ".", "Entities", "{", "result", ":=", "&", "results", "[", "i", "]", "\n\n", "// TODO(fwereade): we shoudn't assume a ApplicationTag: we should", "// use an actual auth func to determine permissions.", "applicationTag", ",", "err", ":=", "names", ".", "ParseApplicationTag", "(", "arg", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "appName", ":=", "applicationTag", ".", "Id", "(", ")", "\n", "if", "appName", "!=", "requireAppName", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "common", ".", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n\n", "settings", ",", "err", ":=", "lsa", ".", "getSettingsFn", "(", "appName", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "result", ".", "Settings", "=", "settings", "\n", "}", "\n\n", "return", "params", ".", "GetLeadershipSettingsBulkResults", "{", "results", "}", ",", "nil", "\n", "}" ]

[ "Read", "reads", "leadership", "settings", "for", "the", "provided", "service", "ID", ".", "Any", "unit", "of", "the", "service", "may", "perform", "this", "operation", "." ]

[ "func", "(", "lsa", "*", "LeadershipSettingsAccessor", ")", "WatchLeadershipSettings", "(", "bulkArgs", "params", ".", "Entities", ")", "(", "params", ".", "NotifyWatchResults", ",", "error", ")", "{", "requireAppName", ",", "err", ":=", "lsa", ".", "callerApplication", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "NotifyWatchResults", "{", "}", ",", "err", "\n", "}", "\n", "results", ":=", "make", "(", "[", "]", "params", ".", "NotifyWatchResult", ",", "len", "(", "bulkArgs", ".", "Entities", ")", ")", "\n\n", "for", "i", ",", "arg", ":=", "range", "bulkArgs", ".", "Entities", "{", "result", ":=", "&", "results", "[", "i", "]", "\n\n", "// TODO(fwereade): we shoudn't assume a ApplicationTag: we should", "// use an actual auth func to determine permissions.", "applicationTag", ",", "err", ":=", "names", ".", "ParseApplicationTag", "(", "arg", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "appName", ":=", "applicationTag", ".", "Id", "(", ")", "\n", "if", "appName", "!=", "requireAppName", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "common", ".", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n\n", "watcherId", ",", "err", ":=", "lsa", ".", "registerWatcherFn", "(", "appName", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "result", ".", "NotifyWatcherId", "=", "watcherId", "\n", "}", "\n", "return", "params", ".", "NotifyWatchResults", "{", "Results", ":", "results", "}", ",", "nil", "\n", "}" ]

[ "WatchLeadershipSettings", "will", "block", "the", "caller", "until", "leadership", "settings", "for", "the", "given", "service", "ID", "change", "." ]

[ "func", "(", "c", "*", "Client", ")", "List", "(", ")", "(", "*", "params", ".", "BackupsListResult", ",", "error", ")", "{", "var", "result", "params", ".", "BackupsListResult", "\n", "args", ":=", "params", ".", "BackupsListArgs", "{", "}", "\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "result", ",", "nil", "\n", "}" ]

[ "List", "implements", "the", "API", "method", "." ]

[ "func", "NewUploadCommand", "(", "deps", "UploadDeps", ")", "modelcmd", ".", "ModelCommand", "{", "return", "modelcmd", ".", "Wrap", "(", "&", "UploadCommand", "{", "deps", ":", "deps", "}", ")", "\n", "}" ]

[ "NewUploadCommand", "returns", "a", "new", "command", "that", "lists", "resources", "defined", "by", "a", "charm", "." ]

[ "func", "(", "c", "*", "UploadCommand", ")", "Info", "(", ")", "*", "cmd", ".", "Info", "{", "return", "jujucmd", ".", "Info", "(", "&", "cmd", ".", "Info", "{", "Name", ":", "\"", "\"", ",", "Args", ":", "\"", "\"", ",", "Purpose", ":", "\"", "\"", ",", "Doc", ":", "attachDoc", ",", "Aliases", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", ")", "\n", "}" ]

[ "Info", "implements", "cmd", ".", "Command", ".", "Info" ]

[ "func", "(", "c", "*", "UploadCommand", ")", "addResourceValue", "(", "arg", "string", ")", "error", "{", "name", ",", "value", ",", "err", ":=", "parseResourceValueArg", "(", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "arg", ")", "\n", "}", "\n", "c", ".", "resourceValue", "=", "resourceValue", "{", "application", ":", "c", ".", "application", ",", "name", ":", "name", ",", "value", ":", "value", ",", "// Default to file resource.", "resourceType", ":", "charmresource", ".", "TypeFile", ",", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "addResourceValue", "parses", "the", "given", "arg", "into", "a", "name", "and", "a", "resource", "value", "and", "saves", "it", "in", "c", ".", "resourceValue", "." ]

[ "func", "(", "c", "*", "UploadCommand", ")", "upload", "(", "rf", "resourceValue", ",", "client", "UploadClient", ")", "error", "{", "f", ",", "err", ":=", "OpenResource", "(", "rf", ".", "value", ",", "rf", ".", "resourceType", ",", "c", ".", "deps", ".", "OpenResource", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "err", "=", "client", ".", "Upload", "(", "rf", ".", "application", ",", "rf", ".", "name", ",", "rf", ".", "value", ",", "f", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "upload", "opens", "the", "given", "file", "and", "calls", "the", "apiclient", "to", "upload", "it", "to", "the", "given", "application", "with", "the", "given", "name", "." ]

[ "func", "(", "gr", "*", "guiRouter", ")", "ensureFileHandler", "(", "h", "func", "(", "gh", "*", "guiHandler", ",", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", ")", "http", ".", "Handler", "{", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "rootDir", ",", "hash", ",", "err", ":=", "gr", ".", "ensureFiles", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "// Note that ensureFiles also checks that the model UUID is valid.", "if", "err", ":=", "sendError", "(", "w", ",", "err", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "qhash", ":=", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "qhash", "!=", "\"", "\"", "&&", "qhash", "!=", "hash", "{", "if", "err", ":=", "sendError", "(", "w", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "qhash", ")", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "gh", ":=", "&", "guiHandler", "{", "ctxt", ":", "gr", ".", "ctxt", ",", "rootDir", ":", "rootDir", ",", "basePath", ":", "guiURLPathPrefix", ",", "hash", ":", "hash", ",", "}", "\n", "h", "(", "gh", ",", "w", ",", "req", ")", "\n", "}", ")", "\n", "}" ]

[ "ensureFileHandler", "decorates", "the", "given", "function", "to", "ensure", "the", "Juju", "GUI", "files", "are", "available", "on", "disk", "." ]

[ "func", "(", "gr", "*", "guiRouter", ")", "ensureFiles", "(", "req", "*", "http", ".", "Request", ")", "(", "rootDir", "string", ",", "hash", "string", ",", "err", "error", ")", "{", "// Retrieve the Juju GUI info from the GUI storage.", "st", ":=", "gr", ".", "ctxt", ".", "srv", ".", "shared", ".", "statePool", ".", "SystemState", "(", ")", "\n", "storage", ",", "err", ":=", "st", ".", "GUIStorage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "storage", ".", "Close", "(", ")", "\n", "vers", ",", "hash", ",", "err", ":=", "guiVersionAndHash", "(", "st", ",", "storage", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "vers", ")", "\n\n", "// Check if the current Juju GUI archive has been already expanded on disk.", "baseDir", ":=", "agenttools", ".", "SharedGUIDir", "(", "gr", ".", "dataDir", ")", "\n", "// Note that we include the hash in the root directory so that when the GUI", "// archive changes we can be sure that clients will not use files from", "// mixed versions.", "rootDir", "=", "filepath", ".", "Join", "(", "baseDir", ",", "hash", ")", "\n", "info", ",", "err", ":=", "os", ".", "Stat", "(", "rootDir", ")", "\n", "if", "err", "==", "nil", "{", "if", "info", ".", "IsDir", "(", ")", "{", "return", "rootDir", ",", "hash", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "rootDir", ")", "\n", "}", "\n", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Fetch the Juju GUI archive from the GUI storage and expand it.", "_", ",", "r", ",", "err", ":=", "storage", ".", "Open", "(", "vers", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "vers", ")", "\n", "}", "\n", "defer", "r", ".", "Close", "(", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "baseDir", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "guiDir", ":=", "\"", "\"", "+", "vers", "+", "\"", "\"", "\n", "if", "err", ":=", "uncompressGUI", "(", "r", ",", "guiDir", ",", "rootDir", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "rootDir", ",", "hash", ",", "nil", "\n", "}" ]

[ "ensureFiles", "checks", "that", "the", "GUI", "files", "are", "available", "on", "disk", ".", "If", "they", "are", "not", "it", "means", "this", "is", "the", "first", "time", "this", "Juju", "GUI", "version", "is", "accessed", ".", "In", "this", "case", "retrieve", "the", "Juju", "GUI", "archive", "from", "the", "storage", "and", "uncompress", "it", "to", "disk", ".", "This", "function", "returns", "the", "current", "GUI", "root", "directory", "and", "archive", "hash", "." ]

[ "func", "guiVersionAndHash", "(", "st", "*", "state", ".", "State", ",", "storage", "binarystorage", ".", "Storage", ")", "(", "vers", ",", "hash", "string", ",", "err", "error", ")", "{", "currentVers", ",", "err", ":=", "st", ".", "GUIVersion", "(", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "metadata", ",", "err", ":=", "storage", ".", "Metadata", "(", "currentVers", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "metadata", ".", "Version", ",", "metadata", ".", "SHA256", ",", "nil", "\n", "}" ]

[ "guiVersionAndHash", "returns", "the", "version", "and", "the", "SHA256", "hash", "of", "the", "current", "Juju", "GUI", "archive", "." ]

[ "func", "uncompressGUI", "(", "r", "io", ".", "Reader", ",", "sourceDir", ",", "targetDir", "string", ")", "error", "{", "tempDir", ",", "err", ":=", "ioutil", ".", "TempDir", "(", "filepath", ".", "Join", "(", "targetDir", ",", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "os", ".", "Remove", "(", "tempDir", ")", "\n", "tr", ":=", "tar", ".", "NewReader", "(", "bzip2", ".", "NewReader", "(", "r", ")", ")", "\n", "for", "{", "hdr", ",", "err", ":=", "tr", ".", "Next", "(", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "hdr", ".", "Name", "!=", "sourceDir", "&&", "!", "strings", ".", "HasPrefix", "(", "hdr", ".", "Name", ",", "sourceDir", "+", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "path", ":=", "filepath", ".", "Join", "(", "tempDir", ",", "hdr", ".", "Name", ")", "\n", "info", ":=", "hdr", ".", "FileInfo", "(", ")", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "path", ",", "info", ".", "Mode", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "f", ",", "err", ":=", "os", ".", "OpenFile", "(", "path", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_TRUNC", "|", "os", ".", "O_WRONLY", ",", "info", ".", "Mode", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "f", ",", "tr", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "os", ".", "Rename", "(", "filepath", ".", "Join", "(", "tempDir", ",", "sourceDir", ")", ",", "targetDir", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "uncompressGUI", "uncompresses", "the", "tar", ".", "bz2", "Juju", "GUI", "archive", "provided", "in", "r", ".", "The", "sourceDir", "directory", "included", "in", "the", "tar", "archive", "is", "copied", "to", "targetDir", "." ]

[ "func", "(", "h", "*", "guiHandler", ")", "serveStatic", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "staticDir", ":=", "filepath", ".", "Join", "(", "h", ".", "rootDir", ",", "\"", "\"", ")", "\n", "fs", ":=", "http", ".", "FileServer", "(", "http", ".", "Dir", "(", "staticDir", ")", ")", "\n", "http", ".", "StripPrefix", "(", "h", ".", "hashedPath", "(", "\"", "\"", ")", ",", "fs", ")", ".", "ServeHTTP", "(", "w", ",", "req", ")", "\n", "}" ]

[ "serveStatic", "serves", "the", "GUI", "static", "files", "." ]

[ "func", "(", "h", "*", "guiHandler", ")", "serveCombo", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "ctype", ":=", "\"", "\"", "\n", "// The combo query is like /combo/?path/to/file1&path/to/file2 ...", "parts", ":=", "strings", ".", "Split", "(", "req", ".", "URL", ".", "RawQuery", ",", "\"", "\"", ")", "\n", "paths", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "parts", ")", ")", "\n", "for", "_", ",", "p", ":=", "range", "parts", "{", "fpath", ",", "err", ":=", "getGUIComboPath", "(", "h", ".", "rootDir", ",", "p", ")", "\n", "if", "err", "!=", "nil", "{", "writeError", "(", "w", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ")", "\n", "return", "\n", "}", "\n", "if", "fpath", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "paths", "=", "append", "(", "paths", ",", "fpath", ")", "\n", "// Assume the Juju GUI does not mix different content types when", "// combining contents.", "if", "ctype", "==", "\"", "\"", "{", "ctype", "=", "mime", ".", "TypeByExtension", "(", "filepath", ".", "Ext", "(", "fpath", ")", ")", "\n", "}", "\n", "}", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "ctype", ")", "\n", "for", "_", ",", "fpath", ":=", "range", "paths", "{", "sendGUIComboFile", "(", "w", ",", "fpath", ")", "\n", "}", "\n", "}" ]

[ "serveCombo", "serves", "the", "GUI", "JavaScript", "and", "CSS", "files", "dynamically", "combined", "." ]

[ "func", "(", "h", "*", "guiHandler", ")", "serveIndex", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "spriteFile", ":=", "filepath", ".", "Join", "(", "h", ".", "rootDir", ",", "spritePath", ")", "\n", "spriteContent", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "spriteFile", ")", "\n", "if", "err", "!=", "nil", "{", "writeError", "(", "w", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ")", "\n", "return", "\n", "}", "\n", "tmpl", ":=", "filepath", ".", "Join", "(", "h", ".", "rootDir", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "renderGUITemplate", "(", "w", ",", "tmpl", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "// staticURL holds the root of the static hierarchy, hence why the", "// empty string is used here.", "\"", "\"", ":", "h", ".", "hashedPath", "(", "\"", "\"", ")", ",", "\"", "\"", ":", "h", ".", "hashedPath", "(", "\"", "\"", ")", ",", "\"", "\"", ":", "h", ".", "hashedPath", "(", "getConfigPath", "(", "req", ".", "URL", ".", "Path", ",", "h", ".", "ctxt", ")", ")", ",", "// TODO frankban: make it possible to enable debug.", "\"", "\"", ":", "false", ",", "\"", "\"", ":", "string", "(", "spriteContent", ")", ",", "}", ")", ";", "err", "!=", "nil", "{", "writeError", "(", "w", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "serveIndex", "serves", "the", "GUI", "index", "file", "." ]

[ "func", "getConfigPath", "(", "path", "string", ",", "ctxt", "httpContext", ")", "string", "{", "configPath", ":=", "\"", "\"", "\n", "// Handle requests from old clients, in which the model UUID is a fragment", "// in the request path. If this is the case, we also need to include the", "// UUID in the GUI base URL.", "uuid", ":=", "uuidFromPath", "(", "path", ")", "\n", "if", "uuid", "!=", "\"", "\"", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "configPath", ",", "uuid", ")", "\n", "}", "\n", "st", ":=", "ctxt", ".", "srv", ".", "shared", ".", "statePool", ".", "SystemState", "(", ")", "\n", "if", "isNewGUI", "(", "st", ")", "{", "// This is the proper case in which a new GUI is being served from a", "// new URL. No query must be included in the config path.", "return", "configPath", "\n", "}", "\n", "// Possibly handle requests to the new \"/u/{user}/{model}\" path, but", "// made from an old version of the GUI, which didn't connect to the", "// model based on the path.", "uuid", ",", "user", ",", "model", ":=", "modelInfoFromPath", "(", "path", ",", "st", ",", "ctxt", ".", "srv", ".", "shared", ".", "statePool", ")", "\n", "if", "uuid", "!=", "\"", "\"", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "configPath", ",", "uuid", ",", "user", ",", "model", ")", "\n", "}", "\n", "return", "configPath", "\n", "}" ]

[ "getConfigPath", "returns", "the", "appropriate", "GUI", "config", "path", "for", "the", "given", "request", "path", "." ]

[ "func", "uuidFromPath", "(", "path", "string", ")", "string", "{", "path", "=", "strings", ".", "TrimPrefix", "(", "path", ",", "guiURLPathPrefix", ")", "\n", "uuid", ":=", "strings", ".", "SplitN", "(", "path", ",", "\"", "\"", ",", "2", ")", "[", "0", "]", "\n", "if", "names", ".", "IsValidModel", "(", "uuid", ")", "{", "return", "uuid", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "uuidFromPath", "checks", "whether", "the", "given", "path", "includes", "a", "fragment", "with", "a", "valid", "model", "UUID", ".", "An", "empty", "string", "is", "returned", "if", "the", "model", "is", "not", "found", "." ]

[ "func", "isNewGUI", "(", "st", "*", "state", ".", "State", ")", "bool", "{", "vers", ",", "err", ":=", "st", ".", "GUIVersion", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "// Assume a recent version of the GUI is being served.", "return", "true", "\n", "}", "\n", "return", "vers", ".", "Major", ">", "2", "||", "(", "vers", ".", "Major", "==", "2", "&&", "vers", ".", "Minor", ">=", "3", ")", "\n", "}" ]

[ "isNewGUI", "reports", "whether", "the", "version", "of", "the", "current", "GUI", "is", ">", "=", "2", ".", "3", ".", "0", "." ]

[ "func", "(", "h", "*", "guiHandler", ")", "serveConfig", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "st", ",", "err", ":=", "h", ".", "ctxt", ".", "stateForRequestUnauthenticated", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "writeError", "(", "w", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ")", "\n", "return", "\n", "}", "\n", "ctrl", ",", "err", ":=", "st", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "writeError", "(", "w", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ")", "\n", "return", "\n", "}", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "jsMimeType", ")", "\n", "base", ":=", "h", ".", "basePath", "\n", "// These query parameters may be set by the index handler.", "uuid", ":=", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "uuid", "!=", "\"", "\"", "{", "base", "+=", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", "\n", "}", "\n", "tmpl", ":=", "filepath", ".", "Join", "(", "h", ".", "rootDir", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "renderGUITemplate", "(", "w", ",", "tmpl", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "base", ",", "\"", "\"", ":", "ctrl", ".", "IdentityURL", "(", ")", "!=", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "ctrl", ".", "CharmStoreURL", "(", ")", ",", "\"", "\"", ":", "req", ".", "Host", ",", "\"", "\"", ":", "\"", "\"", ",", "// staticURL holds the root of the static hierarchy, hence why the", "// empty string is used here.", "\"", "\"", ":", "h", ".", "hashedPath", "(", "\"", "\"", ")", ",", "\"", "\"", ":", "uuid", ",", "\"", "\"", ":", "jujuversion", ".", "Current", ".", "String", "(", ")", ",", "}", ")", ";", "err", "!=", "nil", "{", "writeError", "(", "w", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "serveConfig", "serves", "the", "Juju", "GUI", "JavaScript", "configuration", "file", "." ]

[ "func", "(", "h", "*", "guiArchiveHandler", ")", "handleGet", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "error", "{", "// Open the GUI archive storage.", "st", ",", "err", ":=", "h", ".", "ctxt", ".", "stateForRequestUnauthenticated", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "st", ".", "Release", "(", ")", "\n", "storage", ",", "err", ":=", "st", ".", "GUIStorage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "storage", ".", "Close", "(", ")", "\n\n", "// Retrieve metadata information.", "allMeta", ",", "err", ":=", "storage", ".", "AllMetadata", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Prepare and send the response.", "var", "currentVersion", "string", "\n", "vers", ",", "err", ":=", "st", ".", "GUIVersion", "(", ")", "\n", "if", "err", "==", "nil", "{", "currentVersion", "=", "vers", ".", "String", "(", ")", "\n", "}", "else", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "versions", ":=", "make", "(", "[", "]", "params", ".", "GUIArchiveVersion", ",", "len", "(", "allMeta", ")", ")", "\n", "for", "i", ",", "m", ":=", "range", "allMeta", "{", "vers", ",", "err", ":=", "version", ".", "Parse", "(", "m", ".", "Version", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "versions", "[", "i", "]", "=", "params", ".", "GUIArchiveVersion", "{", "Version", ":", "vers", ",", "SHA256", ":", "m", ".", "SHA256", ",", "Current", ":", "m", ".", "Version", "==", "currentVersion", ",", "}", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "sendStatusAndJSON", "(", "w", ",", "http", ".", "StatusOK", ",", "params", ".", "GUIArchiveResponse", "{", "Versions", ":", "versions", ",", "}", ")", ")", "\n", "}" ]

[ "handleGet", "returns", "information", "on", "Juju", "GUI", "archives", "in", "the", "controller", "." ]

[ "func", "(", "h", "*", "guiArchiveHandler", ")", "handlePost", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "error", "{", "// Validate the request.", "if", "ctype", ":=", "req", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ";", "ctype", "!=", "bzMimeType", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ",", "ctype", ",", "bzMimeType", ")", "\n", "}", "\n", "if", "err", ":=", "req", ".", "ParseForm", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "versParam", ":=", "req", ".", "Form", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "versParam", "==", "\"", "\"", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ")", "\n", "}", "\n", "vers", ",", "err", ":=", "version", ".", "Parse", "(", "versParam", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ",", "versParam", ")", "\n", "}", "\n", "hashParam", ":=", "req", ".", "Form", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "hashParam", "==", "\"", "\"", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "req", ".", "ContentLength", "==", "-", "1", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Open the GUI archive storage.", "st", ",", "err", ":=", "h", ".", "ctxt", ".", "stateForRequestAuthenticatedUser", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "st", ".", "Release", "(", ")", "\n", "storage", ",", "err", ":=", "st", ".", "GUIStorage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "storage", ".", "Close", "(", ")", "\n\n", "// Read and validate the archive data.", "data", ",", "hash", ",", "err", ":=", "readAndHash", "(", "req", ".", "Body", ")", "\n", "size", ":=", "int64", "(", "len", "(", "data", ")", ")", "\n", "if", "size", "!=", "req", ".", "ContentLength", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "hash", "!=", "hashParam", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Add the archive to the GUI storage.", "metadata", ":=", "binarystorage", ".", "Metadata", "{", "Version", ":", "vers", ".", "String", "(", ")", ",", "Size", ":", "size", ",", "SHA256", ":", "hash", ",", "}", "\n", "if", "err", ":=", "storage", ".", "Add", "(", "bytes", ".", "NewReader", "(", "data", ")", ",", "metadata", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Prepare and return the response.", "resp", ":=", "params", ".", "GUIArchiveVersion", "{", "Version", ":", "vers", ",", "SHA256", ":", "hash", ",", "}", "\n", "if", "currentVers", ",", "err", ":=", "st", ".", "GUIVersion", "(", ")", ";", "err", "==", "nil", "{", "if", "currentVers", "==", "vers", "{", "resp", ".", "Current", "=", "true", "\n", "}", "\n", "}", "else", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n\n", "}", "\n", "return", "errors", ".", "Trace", "(", "sendStatusAndJSON", "(", "w", ",", "http", ".", "StatusOK", ",", "resp", ")", ")", "\n", "}" ]

[ "handlePost", "is", "used", "to", "upload", "new", "Juju", "GUI", "archives", "to", "the", "controller", "." ]

[ "func", "(", "h", "*", "guiVersionHandler", ")", "handlePut", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "error", "{", "// Validate the request.", "if", "ctype", ":=", "req", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ";", "ctype", "!=", "params", ".", "ContentTypeJSON", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ",", "ctype", ",", "params", ".", "ContentTypeJSON", ")", "\n", "}", "\n\n", "// Authenticate the request and retrieve the Juju state.", "st", ",", "err", ":=", "h", ".", "ctxt", ".", "stateForRequestAuthenticatedUser", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "st", ".", "Release", "(", ")", "\n\n", "var", "selected", "params", ".", "GUIVersionRequest", "\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "req", ".", "Body", ")", "\n", "if", "err", ":=", "decoder", ".", "Decode", "(", "&", "selected", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "NewBadRequest", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Switch to the provided GUI version.", "if", "err", "=", "st", ".", "GUISetVersion", "(", "selected", ".", "Version", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "handlePut", "is", "used", "to", "switch", "to", "a", "specific", "Juju", "GUI", "version", "." ]

[ "func", "newConnection", "(", "creds", "*", "Credentials", ")", "(", "*", "compute", ".", "Service", ",", "error", ")", "{", "jsonKey", ":=", "creds", ".", "JSONKey", "\n", "if", "jsonKey", "==", "nil", "{", "built", ",", "err", ":=", "creds", ".", "buildJSONKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "jsonKey", "=", "built", "\n", "}", "\n", "cfg", ",", "err", ":=", "goauth2", ".", "JWTConfigFromJSON", "(", "jsonKey", ",", "driverScopes", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "client", ":=", "cfg", ".", "Client", "(", "oauth2", ".", "NoContext", ")", "\n", "service", ",", "err", ":=", "compute", ".", "New", "(", "client", ")", "\n", "return", "service", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "newConnection", "opens", "a", "new", "low", "-", "level", "connection", "to", "the", "GCE", "API", "using", "the", "Auth", "s", "data", "and", "returns", "it", ".", "This", "includes", "building", "the", "OAuth", "-", "wrapping", "network", "transport", "." ]

[ "func", "(", "api", "*", "NetworkConfigAPI", ")", "SetObservedNetworkConfig", "(", "args", "params", ".", "SetMachineNetworkConfig", ")", "error", "{", "m", ",", "err", ":=", "api", ".", "getMachineForSettingNetworkConfig", "(", "args", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "m", ".", "IsContainer", "(", ")", "{", "return", "nil", "\n", "}", "\n", "observedConfig", ":=", "args", ".", "Config", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ",", "observedConfig", ")", "\n", "if", "len", "(", "observedConfig", ")", "==", "0", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n\n", "providerConfig", ",", "err", ":=", "api", ".", "getOneMachineProviderNetworkConfig", "(", "m", ")", "\n", "if", "errors", ".", "IsNotProvisioned", "(", "err", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "mergedConfig", ":=", "observedConfig", "\n", "if", "len", "(", "providerConfig", ")", "!=", "0", "{", "mergedConfig", "=", "MergeProviderAndObservedNetworkConfigs", "(", "providerConfig", ",", "observedConfig", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ",", "mergedConfig", ")", "\n", "}", "\n\n", "mergedConfig", ",", "err", "=", "api", ".", "fixUpFanSubnets", "(", "mergedConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "api", ".", "setOneMachineNetworkConfig", "(", "m", ",", "mergedConfig", ")", "\n", "}" ]

[ "SetObservedNetworkConfig", "reads", "the", "network", "config", "for", "the", "machine", "identified", "by", "the", "input", "args", ".", "This", "config", "is", "merged", "with", "the", "new", "network", "config", "supplied", "in", "the", "same", "args", "and", "updated", "if", "it", "has", "changed", "." ]

[ "func", "(", "api", "*", "NetworkConfigAPI", ")", "SetProviderNetworkConfig", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "args", ")", "\n", "result", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Entities", "{", "m", ",", "err", ":=", "api", ".", "getMachineForSettingNetworkConfig", "(", "arg", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "if", "m", ".", "IsContainer", "(", ")", "{", "continue", "\n", "}", "\n\n", "providerConfig", ",", "err", ":=", "api", ".", "getOneMachineProviderNetworkConfig", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "else", "if", "len", "(", "providerConfig", ")", "==", "0", "{", "continue", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ",", "providerConfig", ")", "\n\n", "if", "err", ":=", "api", ".", "setOneMachineNetworkConfig", "(", "m", ",", "providerConfig", ")", ";", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "SetProviderNetworkConfig", "sets", "the", "provider", "supplied", "network", "configuration", "contained", "in", "the", "input", "args", "against", "each", "machine", "supplied", "with", "said", "args", "." ]

[ "func", "NewPingBatcher", "(", "base", "*", "mgo", ".", "Collection", ",", "flushInterval", "time", ".", "Duration", ")", "*", "PingBatcher", "{", "var", "pings", "*", "mgo", ".", "Collection", "\n", "if", "base", "!=", "nil", "{", "pings", "=", "pingsC", "(", "base", ")", "\n", "}", "\n", "pb", ":=", "&", "PingBatcher", "{", "pings", ":", "pings", ",", "pending", ":", "make", "(", "map", "[", "string", "]", "slot", ")", ",", "flushInterval", ":", "flushInterval", ",", "pingChan", ":", "make", "(", "chan", "singlePing", ")", ",", "syncChan", ":", "make", "(", "chan", "chan", "struct", "{", "}", ")", ",", "syncDelay", ":", "defaultSyncDelay", ",", "rand", ":", "rand", ".", "New", "(", "rand", ".", "NewSource", "(", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", ")", ",", "}", "\n", "pb", ".", "useInc", "=", "checkMongoVersion", "(", "base", ")", "\n", "pb", ".", "start", "(", ")", "\n", "return", "pb", "\n", "}" ]

[ "NewPingBatcher", "creates", "a", "worker", "that", "will", "batch", "ping", "requests", "and", "prepare", "them", "for", "insertion", "into", "the", "Pings", "collection", ".", "Pass", "in", "the", "base", "presence", "collection", ".", "flushInterval", "is", "how", "often", "we", "will", "write", "the", "contents", "to", "the", "database", ".", "It", "should", "be", "shorter", "than", "the", "30s", "slot", "window", "for", "us", "to", "not", "cause", "active", "pingers", "to", "show", "up", "as", "missing", ".", "The", "current", "default", "is", "1s", "as", "it", "provides", "a", "good", "balance", "of", "significant", "-", "batching", "-", "for", "-", "performance", "while", "still", "having", "responsiveness", "to", "agents", "coming", "alive", ".", "Note", "that", "we", "don", "t", "strictly", "sync", "on", "flushInterval", "times", "but", "use", "a", "range", "of", "times", "around", "that", "interval", "to", "avoid", "having", "all", "ping", "batchers", "get", "synchronized", "and", "still", "be", "issuing", "all", "requests", "concurrently", "." ]

[ "func", "NewDeadPingBatcher", "(", "err", "error", ")", "*", "PingBatcher", "{", "// we never start the loop, so the timeout doesn't matter.", "pb", ":=", "&", "PingBatcher", "{", "}", "\n", "pb", ".", "tomb", ".", "Kill", "(", "err", ")", "\n", "return", "pb", "\n", "}" ]

[ "NewDeadPingBatcher", "returns", "a", "PingBatcher", "that", "is", "already", "stopped", "with", "an", "error", "." ]

[ "func", "(", "pb", "*", "PingBatcher", ")", "start", "(", ")", "{", "pb", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "err", ":=", "pb", ".", "loop", "(", ")", "\n", "cause", ":=", "errors", ".", "Cause", "(", "err", ")", "\n", "// tomb expects ErrDying or ErrStillAlive as", "// exact values, so we need to log and unwrap", "// the error first.", "if", "err", "!=", "nil", "&&", "cause", "!=", "tomb", ".", "ErrDying", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "cause", "\n", "}", ")", "\n", "}" ]

[ "Start", "the", "worker", "loop", "." ]

[ "func", "(", "pb", "*", "PingBatcher", ")", "Stop", "(", ")", "error", "{", "if", "err", ":=", "pb", ".", "tomb", ".", "Err", "(", ")", ";", "err", "!=", "tomb", ".", "ErrStillAlive", "{", "return", "err", "\n", "}", "\n", "pb", ".", "tomb", ".", "Kill", "(", "nil", ")", "\n", "err", ":=", "pb", ".", "tomb", ".", "Wait", "(", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "Stop", "this", "PingBatcher", "part", "of", "the", "extended", "Worker", "interface", "." ]

[ "func", "(", "pb", "*", "PingBatcher", ")", "nextSleep", "(", "r", "*", "rand", ".", "Rand", ")", "time", ".", "Duration", "{", "sleepMin", ":=", "float64", "(", "pb", ".", "flushInterval", ")", "*", "0.8", "\n", "sleepRange", ":=", "float64", "(", "pb", ".", "flushInterval", ")", "*", "0.4", "\n", "offset", ":=", "r", ".", "Int63n", "(", "int64", "(", "sleepRange", ")", ")", "\n", "return", "time", ".", "Duration", "(", "int64", "(", "sleepMin", ")", "+", "offset", ")", "\n", "}" ]

[ "nextSleep", "determines", "how", "long", "we", "should", "wait", "before", "flushing", "our", "state", "to", "the", "database", ".", "We", "use", "a", "range", "of", "time", "around", "the", "requested", "flushInterval", "so", "that", "we", "avoid", "having", "all", "requests", "to", "the", "database", "happen", "at", "exactly", "the", "same", "time", "across", "machines", "." ]

[ "func", "(", "pb", "*", "PingBatcher", ")", "Sync", "(", ")", "error", "{", "request", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "select", "{", "case", "pb", ".", "syncChan", "<-", "request", ":", "select", "{", "case", "<-", "request", ":", "return", "nil", "\n", "case", "<-", "pb", ".", "tomb", ".", "Dying", "(", ")", ":", "break", "\n", "}", "\n", "case", "<-", "pb", ".", "tomb", ".", "Dying", "(", ")", ":", "break", "\n", "}", "\n", "if", "err", ":=", "pb", ".", "tomb", ".", "Err", "(", ")", ";", "err", "==", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "else", "{", "return", "err", "\n", "}", "\n", "}" ]

[ "Sync", "schedules", "a", "flush", "of", "the", "current", "state", "to", "the", "database", ".", "This", "is", "not", "immediate", "but", "actually", "within", "a", "short", "timeout", "so", "that", "many", "calls", "to", "sync", "in", "a", "short", "time", "frame", "will", "only", "trigger", "one", "write", "to", "the", "database", "." ]

[ "func", "(", "pb", "*", "PingBatcher", ")", "handlePing", "(", "ping", "singlePing", ")", "{", "docId", ":=", "docIDInt64", "(", "ping", ".", "ModelUUID", ",", "ping", ".", "Slot", ")", "\n", "cur", ",", "slotExists", ":=", "pb", ".", "pending", "[", "docId", "]", "\n", "if", "!", "slotExists", "{", "cur", ".", "Alive", "=", "make", "(", "map", "[", "string", "]", "uint64", ")", "\n", "cur", ".", "Slot", "=", "ping", ".", "Slot", "\n", "pb", ".", "pending", "[", "docId", "]", "=", "cur", "\n", "}", "\n", "alive", ":=", "cur", ".", "Alive", "\n", "alive", "[", "ping", ".", "FieldKey", "]", "|=", "ping", ".", "FieldBit", "\n", "pb", ".", "pingCount", "++", "\n", "}" ]

[ "handlePing", "is", "where", "we", "actually", "update", "our", "internal", "structures", "after", "we", "get", "a", "ping", "request", "." ]

[ "func", "(", "pb", "*", "PingBatcher", ")", "flush", "(", ")", "error", "{", "pb", ".", "flushMutex", ".", "Lock", "(", ")", "\n", "defer", "pb", ".", "flushMutex", ".", "Unlock", "(", ")", "\n\n", "awaiting", ":=", "pb", ".", "awaitingSync", "\n", "pb", ".", "awaitingSync", "=", "nil", "\n", "// We are doing a flush, make sure everyone waiting is told that it has been done", "defer", "func", "(", ")", "{", "for", "_", ",", "waiting", ":=", "range", "awaiting", "{", "close", "(", "waiting", ")", "\n", "}", "\n", "}", "(", ")", "\n", "if", "pb", ".", "pingCount", "==", "0", "{", "return", "nil", "\n", "}", "\n", "uuids", ":=", "set", ".", "NewStrings", "(", ")", "\n", "// We treat all of these as 'consumed'. Even if the query fails, it is", "// not safe to ever $inc the same fields a second time, so we just move on.", "next", ":=", "pb", ".", "pending", "\n", "pingCount", ":=", "pb", ".", "pingCount", "\n", "pb", ".", "pending", "=", "make", "(", "map", "[", "string", "]", "slot", ")", "\n", "pb", ".", "pingCount", "=", "0", "\n", "session", ":=", "pb", ".", "pings", ".", "Database", ".", "Session", ".", "Copy", "(", ")", "\n", "defer", "session", ".", "Close", "(", ")", "\n", "pings", ":=", "pb", ".", "pings", ".", "With", "(", "session", ")", "\n", "docCount", ":=", "0", "\n", "fieldCount", ":=", "0", "\n", "t", ":=", "time", ".", "Now", "(", ")", "\n", "for", "docId", ",", "slot", ":=", "range", "next", "{", "docCount", "++", "\n", "fieldCount", "+=", "len", "(", "slot", ".", "Alive", ")", "\n", "var", "update", "bson", ".", "D", "\n", "if", "pb", ".", "useInc", "{", "update", "=", "pb", ".", "upsertFieldsUsingInc", "(", "slot", ")", "\n", "}", "else", "{", "update", "=", "pb", ".", "upsertFieldsUsingBit", "(", "slot", ")", "\n", "}", "\n", "// Note: UpsertId already handles hitting the DuplicateKey error internally", "// We also just Upsert directly instead of using Bulk because for now each PingBatcher is actually", "// only used by 1 model. Given 30s slots, we only ever hit 1 or 2 documents being updated at the same", "// time. If we switch to sharing batchers between models, then it might make more sense to use bulk updates", "// but then we need to handle when we get Duplicate Key errors during update.", "_", ",", "err", ":=", "pings", ".", "UpsertId", "(", "docId", ",", "update", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "logger", ".", "IsTraceEnabled", "(", ")", "{", "// the rest of Pings records the first 6 characters of", "// model-uuids, so we include that here if we are TRACEing.", "uuids", ".", "Add", "(", "docId", "[", ":", "6", "]", ")", "\n", "}", "\n", "}", "\n", "// usually we should only be processing 1 slot", "logger", ".", "Tracef", "(", "\"", "\"", ",", "pb", ",", "strings", ".", "Join", "(", "uuids", ".", "SortedValues", "(", ")", ",", "\"", "\"", ")", ",", "pingCount", ",", "docCount", ",", "fieldCount", ",", "time", ".", "Since", "(", "t", ")", ".", "Seconds", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "flush", "pushes", "the", "internal", "state", "to", "the", "database", ".", "Note", "that", "if", "the", "database", "updates", "fail", "we", "will", "still", "wipe", "our", "internal", "state", "as", "it", "is", "unsafe", "to", "publish", "the", "same", "updates", "to", "the", "same", "slots", "." ]

[ "func", "NewShowControllerCommand", "(", ")", "cmd", ".", "Command", "{", "cmd", ":=", "&", "showControllerCommand", "{", "store", ":", "jujuclient", ".", "NewFileClientStore", "(", ")", ",", "}", "\n", "return", "modelcmd", ".", "WrapBase", "(", "cmd", ")", "\n", "}" ]

[ "NewShowControllerCommand", "returns", "a", "command", "to", "show", "details", "of", "the", "desired", "controllers", "." ]

[ "func", "RegisterToolsDataSourceFunc", "(", "id", "string", ",", "f", "ToolsDataSourceFunc", ")", "{", "toolsDatasourceFuncsMu", ".", "Lock", "(", ")", "\n", "defer", "toolsDatasourceFuncsMu", ".", "Unlock", "(", ")", "\n", "for", "i", ":=", "range", "toolsDatasourceFuncs", "{", "if", "toolsDatasourceFuncs", "[", "i", "]", ".", "id", "==", "id", "{", "toolsDatasourceFuncs", "[", "i", "]", ".", "f", "=", "f", "\n", "return", "\n", "}", "\n", "}", "\n", "toolsDatasourceFuncs", "=", "append", "(", "toolsDatasourceFuncs", ",", "toolsDatasourceFuncId", "{", "id", ",", "f", "}", ")", "\n", "}" ]

[ "RegisterToolsDataSourceFunc", "registers", "an", "ToolsDataSourceFunc", "with", "the", "specified", "id", "overwriting", "any", "function", "previously", "registered", "with", "the", "same", "id", "." ]

[ "func", "UnregisterToolsDataSourceFunc", "(", "id", "string", ")", "{", "toolsDatasourceFuncsMu", ".", "Lock", "(", ")", "\n", "defer", "toolsDatasourceFuncsMu", ".", "Unlock", "(", ")", "\n", "for", "i", ",", "f", ":=", "range", "toolsDatasourceFuncs", "{", "if", "f", ".", "id", "==", "id", "{", "head", ":=", "toolsDatasourceFuncs", "[", ":", "i", "]", "\n", "tail", ":=", "toolsDatasourceFuncs", "[", "i", "+", "1", ":", "]", "\n", "toolsDatasourceFuncs", "=", "append", "(", "head", ",", "tail", "...", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "UnregisterToolsDataSourceFunc", "unregisters", "an", "ToolsDataSourceFunc", "with", "the", "specified", "id", "." ]

[ "func", "GetMetadataSources", "(", "env", "environs", ".", "BootstrapEnviron", ")", "(", "[", "]", "simplestreams", ".", "DataSource", ",", "error", ")", "{", "config", ":=", "env", ".", "Config", "(", ")", "\n\n", "// Add configured and environment-specific datasources.", "var", "sources", "[", "]", "simplestreams", ".", "DataSource", "\n", "if", "userURL", ",", "ok", ":=", "config", ".", "AgentMetadataURL", "(", ")", ";", "ok", "{", "verify", ":=", "utils", ".", "VerifySSLHostnames", "\n", "if", "!", "config", ".", "SSLHostnameVerification", "(", ")", "{", "verify", "=", "utils", ".", "NoVerifySSLHostnames", "\n", "}", "\n", "sources", "=", "append", "(", "sources", ",", "simplestreams", ".", "NewURLSignedDataSource", "(", "conf", ".", "AgentMetadataURLKey", ",", "userURL", ",", "keys", ".", "JujuPublicKey", ",", "verify", ",", "simplestreams", ".", "SPECIFIC_CLOUD_DATA", ",", "false", ")", ")", "\n", "}", "\n\n", "envDataSources", ",", "err", ":=", "environmentDataSources", "(", "env", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "sources", "=", "append", "(", "sources", ",", "envDataSources", "...", ")", "\n\n", "// Add the default, public datasource.", "defaultURL", ",", "err", ":=", "ToolsURL", "(", "DefaultBaseURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "defaultURL", "!=", "\"", "\"", "{", "sources", "=", "append", "(", "sources", ",", "simplestreams", ".", "NewURLSignedDataSource", "(", "\"", "\"", ",", "defaultURL", ",", "keys", ".", "JujuPublicKey", ",", "utils", ".", "VerifySSLHostnames", ",", "simplestreams", ".", "DEFAULT_CLOUD_DATA", ",", "true", ")", ")", "\n", "}", "\n", "return", "sources", ",", "nil", "\n", "}" ]

[ "GetMetadataSources", "returns", "the", "sources", "to", "use", "when", "looking", "for", "simplestreams", "tools", "metadata", "for", "the", "given", "stream", "." ]

[ "func", "environmentDataSources", "(", "bootstrapEnviron", "environs", ".", "BootstrapEnviron", ")", "(", "[", "]", "simplestreams", ".", "DataSource", ",", "error", ")", "{", "toolsDatasourceFuncsMu", ".", "RLock", "(", ")", "\n", "defer", "toolsDatasourceFuncsMu", ".", "RUnlock", "(", ")", "\n\n", "var", "datasources", "[", "]", "simplestreams", ".", "DataSource", "\n", "env", ",", "ok", ":=", "bootstrapEnviron", ".", "(", "environs", ".", "Environ", ")", "\n", "if", "!", "ok", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "bootstrapEnviron", ")", "\n", "// ignore for CAAS", "return", "datasources", ",", "nil", "\n", "}", "\n", "for", "_", ",", "f", ":=", "range", "toolsDatasourceFuncs", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "f", ".", "id", ")", "\n", "datasource", ",", "err", ":=", "f", ".", "f", "(", "env", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotSupported", "(", "err", ")", "{", "continue", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "datasources", "=", "append", "(", "datasources", ",", "datasource", ")", "\n", "}", "\n", "return", "datasources", ",", "nil", "\n", "}" ]

[ "environmentDataSources", "returns", "simplestreams", "datasources", "for", "the", "environment", "by", "calling", "the", "functions", "registered", "in", "RegisterToolsDataSourceFunc", ".", "The", "datasources", "returned", "will", "be", "in", "the", "same", "order", "the", "functions", "were", "registered", "." ]

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

[ "New", "creates", "a", "new", "client", "-", "side", "ExternalControllerUpdater", "facade", "." ]

[ "func", "(", "c", "*", "Client", ")", "WatchExternalControllers", "(", ")", "(", "watcher", ".", "StringsWatcher", ",", "error", ")", "{", "var", "results", "params", ".", "StringsWatchResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "n", ":=", "len", "(", "results", ".", "Results", ")", ";", "n", "!=", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n", "w", ":=", "apiwatcher", ".", "NewStringsWatcher", "(", "c", ".", "facade", ".", "RawAPICaller", "(", ")", ",", "result", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "WatchExternalControllers", "watches", "for", "the", "addition", "and", "removal", "of", "external", "controllers", "." ]

[ "func", "(", "c", "*", "Client", ")", "ExternalControllerInfo", "(", "controllerUUID", "string", ")", "(", "*", "crossmodel", ".", "ControllerInfo", ",", "error", ")", "{", "if", "!", "names", ".", "IsValidController", "(", "controllerUUID", ")", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "controllerUUID", ")", "\n", "}", "\n", "controllerTag", ":=", "names", ".", "NewControllerTag", "(", "controllerUUID", ")", "\n", "args", ":=", "params", ".", "Entities", "{", "[", "]", "params", ".", "Entity", "{", "{", "Tag", ":", "controllerTag", ".", "String", "(", ")", ",", "}", "}", "}", "\n", "var", "results", "params", ".", "ExternalControllerInfoResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n", "return", "&", "crossmodel", ".", "ControllerInfo", "{", "ControllerTag", ":", "controllerTag", ",", "Alias", ":", "result", ".", "Result", ".", "Alias", ",", "Addrs", ":", "result", ".", "Result", ".", "Addrs", ",", "CACert", ":", "result", ".", "Result", ".", "CACert", ",", "}", ",", "nil", "\n", "}" ]

[ "ExternalControllerInfo", "returns", "the", "info", "for", "the", "external", "controller", "with", "the", "specified", "UUID", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetExternalControllerInfo", "(", "info", "crossmodel", ".", "ControllerInfo", ")", "error", "{", "var", "results", "params", ".", "ErrorResults", "\n", "args", ":=", "params", ".", "SetExternalControllersInfoParams", "{", "Controllers", ":", "[", "]", "params", ".", "SetExternalControllerInfoParams", "{", "{", "Info", ":", "params", ".", "ExternalControllerInfo", "{", "ControllerTag", ":", "info", ".", "ControllerTag", ".", "String", "(", ")", ",", "Alias", ":", "info", ".", "Alias", ",", "Addrs", ":", "info", ".", "Addrs", ",", "CACert", ":", "info", ".", "CACert", ",", "}", ",", "}", "}", ",", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "results", ".", "OneError", "(", ")", "\n", "}" ]

[ "SetExternalControllerInfo", "saves", "the", "given", "controller", "info", "." ]

[ "func", "(", "c", "*", "cloudSpecAuth", ")", "WithAuthorization", "(", ")", "autorest", ".", "PrepareDecorator", "{", "return", "func", "(", "p", "autorest", ".", "Preparer", ")", "autorest", ".", "Preparer", "{", "return", "autorest", ".", "PreparerFunc", "(", "func", "(", "r", "*", "http", ".", "Request", ")", "(", "*", "http", ".", "Request", ",", "error", ")", "{", "r", ",", "err", ":=", "p", ".", "Prepare", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "token", ",", "err", ":=", "c", ".", "getToken", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "authorizer", ":=", "autorest", ".", "NewBearerAuthorizer", "(", "token", ")", "\n", "return", "autorest", ".", "CreatePreparer", "(", "authorizer", ".", "WithAuthorization", "(", ")", ")", ".", "Prepare", "(", "r", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "WithAuthorization", "is", "part", "of", "the", "autorest", ".", "Authorizer", "interface", "." ]

[ "func", "AuthToken", "(", "cloud", "environs", ".", "CloudSpec", ",", "sender", "autorest", ".", "Sender", ")", "(", "*", "adal", ".", "ServicePrincipalToken", ",", "error", ")", "{", "if", "authType", ":=", "cloud", ".", "Credential", ".", "AuthType", "(", ")", ";", "authType", "!=", "clientCredentialsAuthType", "{", "// We currently only support a single auth-type for", "// non-interactive authentication. Interactive auth", "// is used only to generate a service-principal.", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ",", "authType", ")", "\n", "}", "\n\n", "resourceId", ",", "err", ":=", "azureauth", ".", "ResourceManagerResourceId", "(", "cloud", ".", "StorageEndpoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "credAttrs", ":=", "cloud", ".", "Credential", ".", "Attributes", "(", ")", "\n", "subscriptionId", ":=", "credAttrs", "[", "credAttrSubscriptionId", "]", "\n", "appId", ":=", "credAttrs", "[", "credAttrAppId", "]", "\n", "appPassword", ":=", "credAttrs", "[", "credAttrAppPassword", "]", "\n", "client", ":=", "subscriptions", ".", "Client", "{", "subscriptions", ".", "NewWithBaseURI", "(", "cloud", ".", "Endpoint", ")", "}", "\n", "useragent", ".", "UpdateClient", "(", "&", "client", ".", "Client", ")", "\n", "client", ".", "Sender", "=", "sender", "\n", "sdkCtx", ":=", "context", ".", "Background", "(", ")", "\n", "oauthConfig", ",", "_", ",", "err", ":=", "azureauth", ".", "OAuthConfig", "(", "sdkCtx", ",", "client", ",", "cloud", ".", "Endpoint", ",", "subscriptionId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "token", ",", "err", ":=", "adal", ".", "NewServicePrincipalToken", "(", "*", "oauthConfig", ",", "appId", ",", "appPassword", ",", "resourceId", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "tokenClient", ":=", "autorest", ".", "NewClientWithUserAgent", "(", "\"", "\"", ")", "\n", "useragent", ".", "UpdateClient", "(", "&", "tokenClient", ")", "\n", "tokenClient", ".", "Sender", "=", "sender", "\n", "token", ".", "SetSender", "(", "&", "tokenClient", ")", "\n", "return", "token", ",", "nil", "\n", "}" ]

[ "AuthToken", "returns", "a", "service", "principal", "token", "suitable", "for", "authorizing", "Resource", "Manager", "API", "requests", "based", "on", "the", "supplied", "CloudSpec", "." ]

[ "func", "(", "c", "*", "Client", ")", "Upload", "(", "archive", "io", ".", "ReadSeeker", ",", "meta", "params", ".", "BackupsMetadataResult", ")", "(", "string", ",", "error", ")", "{", "// Empty out some of the metadata.", "meta", ".", "ID", "=", "\"", "\"", "\n", "meta", ".", "Stored", "=", "time", ".", "Time", "{", "}", "\n\n", "req", ",", "err", ":=", "http", ".", "NewRequest", "(", "\"", "\"", ",", "\"", "\"", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "body", ",", "contentType", ",", "err", ":=", "httpattachment", ".", "NewBody", "(", "archive", ",", "meta", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "contentType", ")", "\n", "var", "result", "params", ".", "BackupsUploadResult", "\n", "if", "err", ":=", "c", ".", "client", ".", "Do", "(", "req", ",", "body", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "result", ".", "ID", ",", "nil", "\n", "}" ]

[ "Upload", "sends", "the", "backup", "archive", "to", "remote", "storage", "." ]

[ "func", "NewReachableChecker", "(", "dialer", "Dialer", ",", "timeout", "time", ".", "Duration", ")", "*", "reachableChecker", "{", "return", "&", "reachableChecker", "{", "dialer", ":", "dialer", ",", "timeout", ":", "timeout", ",", "}", "\n", "}" ]

[ "NewReachableChecker", "creates", "a", "ReachableChecker", "that", "can", "be", "used", "to", "check", "for", "Hosts", "that", "are", "viable", "SSH", "targets", ".", "When", "FindHost", "is", "called", "we", "will", "dial", "the", "entries", "in", "the", "given", "hostPorts", "in", "parallel", "using", "the", "given", "dialer", "closing", "successfully", "established", "connections", "after", "checking", "the", "ssh", "key", ".", "Individual", "connection", "errors", "are", "discarded", "and", "an", "error", "is", "returned", "only", "if", "none", "of", "the", "hostPorts", "can", "be", "reached", "when", "the", "given", "timeout", "expires", ".", "If", "publicKeys", "is", "a", "non", "empty", "list", "then", "the", "SSH", "host", "public", "key", "will", "be", "checked", ".", "If", "it", "is", "not", "in", "the", "list", "that", "host", "is", "not", "considered", "valid", ".", "Usually", "a", "net", ".", "Dialer", "initialized", "with", "a", "non", "-", "empty", "Timeout", "field", "is", "passed", "for", "dialer", "." ]

[ "func", "(", "h", "*", "hostKeyChecker", ")", "Check", "(", ")", "{", "defer", "func", "(", ")", "{", "// send a finished message unless we're already stopped and nobody", "// is listening", "if", "h", ".", "Finished", "!=", "nil", "{", "select", "{", "case", "h", ".", "Finished", "<-", "struct", "{", "}", "{", "}", ":", "case", "<-", "h", ".", "Stop", ":", "}", "\n", "}", "\n", "}", "(", ")", "\n", "// TODO(jam): 2017-01-24 One limitation of our algorithm, is that we don't", "// try to limit the negotiation of the keys to our set of possible keys.", "// For example, say we only know about the RSA key for the remote host, but", "// it has been updated to use a ECDSA key as well. Gocrypto/ssh might", "// negotiate to use the \"more secure\" ECDSA key and we will see that", "// as an invalid key.", "sshconfig", ":=", "&", "ssh", ".", "ClientConfig", "{", "HostKeyCallback", ":", "h", ".", "hostKeyCallback", ",", "}", "\n", "addr", ":=", "h", ".", "HostPort", ".", "NetAddr", "(", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "addr", ")", "\n", "conn", ",", "err", ":=", "h", ".", "Dialer", ".", "Dial", "(", "\"", "\"", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "addr", ",", "err", ")", "\n", "return", "\n", "}", "\n", "// No need to do the key exchange if we're already stopping", "select", "{", "case", "<-", "h", ".", "Stop", ":", "conn", ".", "Close", "(", ")", "\n", "return", "\n", "default", ":", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "addr", ")", "\n", "// NewClientConn will close the underlying net.Conn if it gets an error", "client", ",", "_", ",", "_", ",", "err", ":=", "ssh", ".", "NewClientConn", "(", "conn", ",", "addr", ",", "sshconfig", ")", "\n", "if", "err", "==", "nil", "{", "// We don't expect this case, because we don't support Auth,", "// but make sure to close it anyway.", "client", ".", "Close", "(", ")", "\n", "}", "else", "{", "// no need to log these two messages, that's already been done", "// in hostKeyCallback", "if", "!", "strings", ".", "Contains", "(", "err", ".", "Error", "(", ")", ",", "hostKeyAccepted", ".", "Error", "(", ")", ")", "&&", "!", "strings", ".", "Contains", "(", "err", ".", "Error", "(", ")", ",", "hostKeyNotInList", ".", "Error", "(", ")", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Check", "initiates", "a", "connection", "to", "HostPort", "and", "tries", "to", "do", "an", "SSH", "key", "exchange", "to", "determine", "the", "preferred", "public", "key", "of", "the", "remote", "host", ".", "It", "then", "checks", "if", "that", "key", "is", "in", "the", "accepted", "set", "of", "keys", "." ]

[ "func", "(", "r", "*", "reachableChecker", ")", "FindHost", "(", "hostPorts", "[", "]", "network", ".", "HostPort", ",", "publicKeys", "[", "]", "string", ")", "(", "network", ".", "HostPort", ",", "error", ")", "{", "uniqueHPs", ":=", "network", ".", "UniqueHostPorts", "(", "hostPorts", ")", "\n", "successful", ":=", "make", "(", "chan", "network", ".", "HostPort", ")", "\n", "stop", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "// We use a channel instead of a sync.WaitGroup so that we can return as", "// soon as we get one connected. We'll signal the rest to stop via the", "// 'stop' channel.", "finished", ":=", "make", "(", "chan", "struct", "{", "}", ",", "len", "(", "uniqueHPs", ")", ")", "\n\n", "acceptedKeys", ":=", "publicKeysToSet", "(", "publicKeys", ")", "\n", "for", "_", ",", "hostPort", ":=", "range", "uniqueHPs", "{", "checker", ":=", "&", "hostKeyChecker", "{", "AcceptedKeys", ":", "acceptedKeys", ",", "Stop", ":", "stop", ",", "Accepted", ":", "successful", ",", "HostPort", ":", "hostPort", ",", "Dialer", ":", "r", ".", "dialer", ",", "Finished", ":", "finished", ",", "}", "\n", "go", "checker", ".", "Check", "(", ")", "\n", "}", "\n\n", "timeout", ":=", "time", ".", "After", "(", "r", ".", "timeout", ")", "\n", "for", "finishedCount", ":=", "0", ";", "finishedCount", "<", "len", "(", "uniqueHPs", ")", ";", "{", "select", "{", "case", "result", ":=", "<-", "successful", ":", "logger", ".", "Infof", "(", "\"", "\"", ",", "result", ")", "\n", "close", "(", "stop", ")", "\n", "return", "result", ",", "nil", "\n", "case", "<-", "finished", ":", "finishedCount", "++", "\n", "case", "<-", "timeout", ":", "break", "\n", "}", "\n", "}", "\n", "close", "(", "stop", ")", "\n", "return", "network", ".", "HostPort", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "hostPorts", ")", "\n", "}" ]

[ "FindHost", "takes", "a", "list", "of", "possible", "host", "+", "port", "combinations", "and", "possible", "public", "keys", "that", "the", "SSH", "server", "could", "be", "using", ".", "We", "make", "an", "attempt", "to", "connect", "to", "each", "of", "those", "addresses", "and", "do", "an", "SSH", "handshake", "negotiation", ".", "We", "then", "check", "if", "the", "SSH", "server", "s", "negotiated", "public", "key", "is", "in", "our", "allowed", "set", ".", "The", "first", "address", "to", "successfully", "negotiate", "will", "be", "returned", ".", "If", "none", "of", "them", "succeed", "and", "error", "will", "be", "returned", "." ]

[ "func", "NewAttachments", "(", "st", "StorageAccessor", ",", "tag", "names", ".", "UnitTag", ",", "storageStateDir", "string", ",", "abort", "<-", "chan", "struct", "{", "}", ",", ")", "(", "*", "Attachments", ",", "error", ")", "{", "a", ":=", "&", "Attachments", "{", "st", ":", "st", ",", "unitTag", ":", "tag", ",", "abort", ":", "abort", ",", "storageAttachments", ":", "make", "(", "map", "[", "names", ".", "StorageTag", "]", "storageAttachment", ")", ",", "storageStateDir", ":", "storageStateDir", ",", "pending", ":", "names", ".", "NewSet", "(", ")", ",", "}", "\n", "if", "err", ":=", "a", ".", "init", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "a", ",", "nil", "\n", "}" ]

[ "NewAttachments", "returns", "a", "new", "Attachments", "." ]

[ "func", "(", "a", "*", "Attachments", ")", "init", "(", ")", "error", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "a", ".", "storageStateDir", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "// Query all remote, known storage attachments for the unit,", "// so we can cull state files, and store current context.", "attachmentIds", ",", "err", ":=", "a", ".", "st", ".", "UnitStorageAttachments", "(", "a", ".", "unitTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "attachmentsByTag", ":=", "make", "(", "map", "[", "names", ".", "StorageTag", "]", "struct", "{", "}", ")", "\n", "for", "_", ",", "attachmentId", ":=", "range", "attachmentIds", "{", "storageTag", ",", "err", ":=", "names", ".", "ParseStorageTag", "(", "attachmentId", ".", "StorageTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "attachmentsByTag", "[", "storageTag", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "stateFiles", ",", "err", ":=", "readAllStateFiles", "(", "a", ".", "storageStateDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "storageTag", ",", "stateFile", ":=", "range", "stateFiles", "{", "if", "_", ",", "ok", ":=", "attachmentsByTag", "[", "storageTag", "]", ";", "!", "ok", "{", "// We have previously removed the storage from state,", "// but did not remove the state file. Remove the file.", "if", "err", ":=", "stateFile", ".", "Remove", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "// Since there's a state file, we must previously have handled", "// at least \"storage-attached\", so there is no possibility of", "// short-circuiting the storage's removal.", "attachment", ",", "err", ":=", "a", ".", "st", ".", "StorageAttachment", "(", "storageTag", ",", "a", ".", "unitTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "storageTag", ".", "Id", "(", ")", ",", ")", "\n", "}", "\n", "a", ".", "storageAttachments", "[", "storageTag", "]", "=", "storageAttachment", "{", "stateFile", ",", "&", "contextStorage", "{", "tag", ":", "storageTag", ",", "kind", ":", "storage", ".", "StorageKind", "(", "attachment", ".", "Kind", ")", ",", "location", ":", "attachment", ".", "Location", ",", "}", ",", "}", "\n", "}", "\n", "for", "storageTag", ":=", "range", "attachmentsByTag", "{", "if", "_", ",", "ok", ":=", "stateFiles", "[", "storageTag", "]", ";", "!", "ok", "{", "// There is no state file for the attachment, so no", "// hooks have been committed for it.", "a", ".", "pending", ".", "Add", "(", "storageTag", ")", "\n", "}", "\n", "// Non-locally recorded attachments will be further handled", "// by the resolver.", "}", "\n", "return", "nil", "\n", "}" ]

[ "init", "processes", "the", "storage", "state", "directory", "and", "creates", "storagers", "for", "the", "state", "files", "found", "." ]

[ "func", "(", "a", "*", "Attachments", ")", "SetDying", "(", ")", "error", "{", "if", "err", ":=", "a", ".", "st", ".", "DestroyUnitStorageAttachments", "(", "a", ".", "unitTag", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetDying", "ensures", "that", "any", "unprovisioned", "storage", "attachments", "are", "removed", "from", "state", "." ]

[ "func", "(", "a", "*", "Attachments", ")", "Storage", "(", "tag", "names", ".", "StorageTag", ")", "(", "jujuc", ".", "ContextStorageAttachment", ",", "error", ")", "{", "if", "attachment", ",", "ok", ":=", "a", ".", "storageAttachments", "[", "tag", "]", ";", "ok", "{", "return", "attachment", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}" ]

[ "Storage", "returns", "the", "ContextStorage", "with", "the", "supplied", "tag", "if", "it", "was", "found", "and", "whether", "it", "was", "found", "." ]

[ "func", "(", "a", "*", "Attachments", ")", "StorageTags", "(", ")", "(", "[", "]", "names", ".", "StorageTag", ",", "error", ")", "{", "tags", ":=", "names", ".", "NewSet", "(", ")", "\n", "for", "tag", ":=", "range", "a", ".", "storageAttachments", "{", "tags", ".", "Add", "(", "tag", ")", "\n", "}", "\n", "storageTags", ":=", "make", "(", "[", "]", "names", ".", "StorageTag", ",", "tags", ".", "Size", "(", ")", ")", "\n", "for", "i", ",", "tag", ":=", "range", "tags", ".", "SortedValues", "(", ")", "{", "storageTags", "[", "i", "]", "=", "tag", ".", "(", "names", ".", "StorageTag", ")", "\n", "}", "\n", "return", "storageTags", ",", "nil", "\n", "}" ]

[ "StorageTags", "returns", "the", "names", ".", "StorageTags", "for", "the", "active", "storage", "attachments", "." ]

[ "func", "(", "a", "*", "Attachments", ")", "ValidateHook", "(", "hi", "hook", ".", "Info", ")", "error", "{", "storageState", ",", "err", ":=", "a", ".", "storageStateForHook", "(", "hi", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "storageState", ".", "ValidateHook", "(", "hi", ")", "\n", "}" ]

[ "ValidateHook", "validates", "the", "hook", "against", "the", "current", "state", "." ]

[ "func", "(", "a", "*", "Attachments", ")", "CommitHook", "(", "hi", "hook", ".", "Info", ")", "error", "{", "storageState", ",", "err", ":=", "a", ".", "storageStateForHook", "(", "hi", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "storageState", ".", "CommitHook", "(", "hi", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "storageTag", ":=", "names", ".", "NewStorageTag", "(", "hi", ".", "StorageId", ")", "\n", "switch", "hi", ".", "Kind", "{", "case", "hooks", ".", "StorageAttached", ":", "a", ".", "pending", ".", "Remove", "(", "storageTag", ")", "\n", "case", "hooks", ".", "StorageDetaching", ":", "if", "err", ":=", "a", ".", "removeStorageAttachment", "(", "storageTag", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CommitHook", "persists", "the", "state", "change", "encoded", "in", "the", "supplied", "storage", "hook", "or", "returns", "an", "error", "if", "the", "hook", "is", "invalid", "given", "current", "state", "." ]

[ "func", "(", "e", "*", "RequestError", ")", "UnmarshalInfo", "(", "to", "interface", "{", "}", ")", "error", "{", "if", "reflect", ".", "ValueOf", "(", "to", ")", ".", "Kind", "(", ")", "!=", "reflect", ".", "Ptr", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "data", ",", "err", ":=", "json", ".", "Marshal", "(", "e", ".", "Info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "data", ",", "to", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "UnmarshalInfo", "attempts", "to", "unmarshal", "the", "information", "contained", "in", "the", "Info", "field", "of", "a", "RequestError", "into", "an", "object", "instance", "a", "pointer", "to", "which", "is", "passed", "via", "the", "to", "argument", ".", "The", "method", "will", "return", "an", "error", "if", "a", "non", "-", "pointer", "arg", "is", "provided", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "Call", "(", "req", "Request", ",", "params", ",", "response", "interface", "{", "}", ")", "error", "{", "call", ":=", "&", "Call", "{", "Request", ":", "req", ",", "Params", ":", "params", ",", "Response", ":", "response", ",", "Done", ":", "make", "(", "chan", "*", "Call", ",", "1", ")", ",", "}", "\n", "conn", ".", "send", "(", "call", ")", "\n", "result", ":=", "<-", "call", ".", "Done", "\n", "return", "errors", ".", "Trace", "(", "result", ".", "Error", ")", "\n", "}" ]

[ "Call", "invokes", "the", "named", "action", "on", "the", "object", "of", "the", "given", "type", "with", "the", "given", "id", ".", "The", "returned", "values", "will", "be", "stored", "in", "response", "which", "should", "be", "a", "pointer", ".", "If", "the", "action", "fails", "remotely", "the", "error", "will", "have", "a", "cause", "of", "type", "RequestError", ".", "The", "params", "value", "may", "be", "nil", "if", "no", "parameters", "are", "provided", ";", "the", "response", "value", "may", "be", "nil", "to", "indicate", "that", "any", "result", "should", "be", "discarded", "." ]

[ "func", "(", "st", "*", "State", ")", "InvalidateModelCredential", "(", "reason", "string", ")", "error", "{", "m", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "tag", ",", "exists", ":=", "m", ".", "CloudCredential", "(", ")", "\n", "if", "!", "exists", "{", "// Model is on the cloud that does not require auth - nothing to do.", "return", "nil", "\n", "}", "\n\n", "return", "errors", ".", "Trace", "(", "st", ".", "InvalidateCloudCredential", "(", "tag", ",", "reason", ")", ")", "\n", "}" ]

[ "InvalidateModelCredential", "invalidate", "cloud", "credential", "for", "the", "model", "of", "the", "given", "state", "." ]

[ "func", "(", "m", "*", "Model", ")", "ValidateCloudCredential", "(", "tag", "names", ".", "CloudCredentialTag", ",", "credential", "cloud", ".", "Credential", ")", "error", "{", "cloud", ",", "err", ":=", "m", ".", "st", ".", "Cloud", "(", "m", ".", "Cloud", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "m", ".", "Cloud", "(", ")", ")", "\n", "}", "\n\n", "err", "=", "validateCredentialForCloud", "(", "cloud", ",", "tag", ",", "convertCloudCredentialToState", "(", "tag", ",", "credential", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ",", "cloud", ".", "Name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateCloudCredential", "validates", "new", "cloud", "credential", "for", "this", "model", "." ]

[ "func", "(", "m", "*", "Model", ")", "SetCloudCredential", "(", "tag", "names", ".", "CloudCredentialTag", ")", "(", "bool", ",", "error", ")", "{", "cloud", ",", "err", ":=", "m", ".", "st", ".", "Cloud", "(", "m", ".", "Cloud", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "m", ".", "Cloud", "(", ")", ")", "\n", "}", "\n", "updating", ":=", "true", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "if", "attempt", ">", "0", "{", "if", "err", ":=", "m", ".", "Refresh", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "tag", ".", "Id", "(", ")", "==", "m", ".", "doc", ".", "CloudCredential", "{", "updating", "=", "false", "\n", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "// Must be a valid credential that is already on the controller.", "credential", ",", "err", ":=", "m", ".", "st", ".", "CloudCredential", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "credential", ".", "IsValid", "(", ")", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "}", "\n", "if", "err", ":=", "validateCredentialForCloud", "(", "cloud", ",", "tag", ",", "credential", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "modelsC", ",", "Id", ":", "m", ".", "doc", ".", "UUID", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "tag", ".", "Id", "(", ")", "}", "}", "}", "}", ",", "}", "}", ",", "nil", "\n", "}", "\n", "if", "err", ":=", "m", ".", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "updating", ",", "m", ".", "Refresh", "(", ")", "\n", "}" ]

[ "SetCloudCredential", "sets", "new", "cloud", "credential", "for", "this", "model", ".", "Returned", "bool", "indicates", "if", "model", "credential", "was", "set", "." ]

[ "func", "(", "m", "*", "Model", ")", "WatchModelCredential", "(", ")", "NotifyWatcher", "{", "current", ":=", "m", ".", "doc", ".", "CloudCredential", "\n", "filter", ":=", "func", "(", "id", "interface", "{", "}", ")", "bool", "{", "id", ",", "ok", ":=", "id", ".", "(", "string", ")", "\n", "if", "!", "ok", "||", "id", "!=", "m", ".", "doc", ".", "UUID", "{", "return", "false", "\n", "}", "\n\n", "models", ",", "closer", ":=", "m", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "modelsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "doc", "*", "modelDoc", "\n", "if", "err", ":=", "models", ".", "FindId", "(", "id", ")", ".", "One", "(", "&", "doc", ")", ";", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n\n", "match", ":=", "current", "!=", "doc", ".", "CloudCredential", "\n", "current", "=", "doc", ".", "CloudCredential", "\n", "return", "match", "\n", "}", "\n", "return", "newNotifyCollWatcher", "(", "m", ".", "st", ",", "modelsC", ",", "filter", ")", "\n", "}" ]

[ "WatchModelCredential", "returns", "a", "new", "NotifyWatcher", "that", "watches", "a", "model", "reference", "to", "a", "cloud", "credential", "." ]

[ "func", "(", "api", "*", "API", ")", "OpenMessageWriter", "(", ")", "(", "MessageWriter", ",", "error", ")", "{", "conn", ",", "err", ":=", "api", ".", "connector", ".", "ConnectStream", "(", "\"", "\"", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "messageWriter", ":=", "&", "writer", "{", "conn", "}", "\n", "go", "messageWriter", ".", "readLoop", "(", ")", "\n", "return", "messageWriter", ",", "nil", "\n", "}" ]

[ "OpenMessageWriter", "returns", "a", "new", "message", "writer", "interface", "value", "which", "must", "be", "closed", "when", "finished", "with", "." ]

[ "func", "NewSchedule", "(", "clock", "clock", ".", "Clock", ")", "*", "Schedule", "{", "return", "&", "Schedule", "{", "time", ":", "clock", ",", "m", ":", "make", "(", "map", "[", "interface", "{", "}", "]", "*", "scheduleItem", ")", ",", "}", "\n", "}" ]

[ "NewSchedule", "constructs", "a", "new", "schedule", "using", "the", "given", "Clock", "for", "the", "Next", "method", "." ]

[ "func", "(", "s", "*", "Schedule", ")", "Next", "(", ")", "<-", "chan", "time", ".", "Time", "{", "if", "len", "(", "s", ".", "items", ")", ">", "0", "{", "return", "s", ".", "time", ".", "After", "(", "s", ".", "items", "[", "0", "]", ".", "t", ".", "Sub", "(", "s", ".", "time", ".", "Now", "(", ")", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Next", "returns", "a", "channel", "which", "will", "send", "after", "the", "next", "scheduled", "item", "s", "time", "has", "been", "reached", ".", "If", "there", "are", "no", "scheduled", "items", "nil", "is", "returned", "." ]

[ "func", "(", "s", "*", "Schedule", ")", "Ready", "(", "now", "time", ".", "Time", ")", "[", "]", "interface", "{", "}", "{", "var", "ready", "[", "]", "interface", "{", "}", "\n", "for", "len", "(", "s", ".", "items", ")", ">", "0", "&&", "!", "s", ".", "items", "[", "0", "]", ".", "t", ".", "After", "(", "now", ")", "{", "item", ":=", "heap", ".", "Pop", "(", "&", "s", ".", "items", ")", ".", "(", "*", "scheduleItem", ")", "\n", "delete", "(", "s", ".", "m", ",", "item", ".", "key", ")", "\n", "ready", "=", "append", "(", "ready", ",", "item", ".", "value", ")", "\n", "}", "\n", "return", "ready", "\n", "}" ]

[ "Ready", "returns", "the", "parameters", "for", "items", "that", "are", "scheduled", "at", "or", "before", "now", "and", "removes", "them", "from", "the", "schedule", ".", "The", "resulting", "slices", "are", "in", "order", "of", "time", ";", "items", "scheduled", "for", "the", "same", "time", "have", "no", "defined", "relative", "order", "." ]

[ "func", "(", "s", "*", "Schedule", ")", "Add", "(", "key", ",", "value", "interface", "{", "}", ",", "t", "time", ".", "Time", ")", "{", "if", "_", ",", "ok", ":=", "s", ".", "m", "[", "key", "]", ";", "ok", "{", "panic", "(", "errors", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", ")", "\n", "}", "\n", "item", ":=", "&", "scheduleItem", "{", "key", ":", "key", ",", "value", ":", "value", ",", "t", ":", "t", "}", "\n", "s", ".", "m", "[", "key", "]", "=", "item", "\n", "heap", ".", "Push", "(", "&", "s", ".", "items", ",", "item", ")", "\n", "}" ]

[ "Add", "adds", "an", "item", "with", "the", "specified", "value", "with", "the", "corresponding", "key", "and", "time", "to", "the", "schedule", ".", "Add", "will", "panic", "if", "there", "already", "exists", "an", "item", "with", "the", "same", "key", "." ]

[ "func", "(", "s", "*", "Schedule", ")", "Remove", "(", "key", "interface", "{", "}", ")", "{", "if", "item", ",", "ok", ":=", "s", ".", "m", "[", "key", "]", ";", "ok", "{", "heap", ".", "Remove", "(", "&", "s", ".", "items", ",", "item", ".", "i", ")", "\n", "delete", "(", "s", ".", "m", ",", "key", ")", "\n", "}", "\n", "}" ]

[ "Remove", "removes", "the", "item", "corresponding", "to", "the", "specified", "key", "from", "the", "schedule", ".", "If", "no", "item", "with", "the", "specified", "key", "exists", "this", "is", "a", "no", "-", "op", "." ]

[ "func", "(", "r", "*", "RebootRequester", ")", "RequestReboot", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "result", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "if", "len", "(", "args", ".", "Entities", ")", "==", "0", "{", "return", "result", ",", "nil", "\n", "}", "\n", "auth", ",", "err", ":=", "r", ".", "auth", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n", "err", "=", "ErrPerm", "\n", "if", "auth", "(", "tag", ")", "{", "err", "=", "r", ".", "oneRequest", "(", "tag", ")", "\n", "}", "\n", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "RequestReboot", "sets", "the", "reboot", "flag", "on", "the", "provided", "machines" ]

[ "func", "(", "p", "OpenParams", ")", "Validate", "(", ")", "error", "{", "if", "p", ".", "Clock", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "p", ".", "ControllerTag", "==", "(", "names", ".", "ControllerTag", "{", "}", ")", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "p", ".", "ControllerModelTag", "==", "(", "names", ".", "ModelTag", "{", "}", ")", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "p", ".", "MongoSession", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

[ "func", "OpenController", "(", "args", "OpenParams", ")", "(", "*", "Controller", ",", "error", ")", "{", "pool", ",", "err", ":=", "OpenStatePool", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "Controller", "{", "pool", ":", "pool", ",", "ownsPool", ":", "true", ",", "}", ",", "nil", "\n", "}" ]

[ "OpenController", "connects", "to", "the", "server", "with", "the", "given", "parameters", "waits", "for", "it", "to", "be", "initialized", "and", "returns", "a", "new", "Controller", "instance", ".", "OpenController", "returns", "unauthorizedError", "if", "access", "is", "unauthorized", "." ]

[ "func", "Open", "(", "args", "OpenParams", ")", "(", "*", "State", ",", "error", ")", "{", "if", "err", ":=", "args", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "session", ":=", "args", ".", "MongoSession", ".", "Copy", "(", ")", "\n", "st", ",", "err", ":=", "open", "(", "args", ".", "ControllerModelTag", ",", "session", ",", "args", ".", "InitDatabaseFunc", ",", "nil", ",", "args", ".", "NewPolicy", ",", "args", ".", "Clock", ",", "args", ".", "RunTransactionObserver", ",", ")", "\n", "if", "err", "!=", "nil", "{", "session", ".", "Close", "(", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "st", ".", "Model", "(", ")", ";", "err", "!=", "nil", "{", "if", "err", ":=", "st", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "args", ".", "ControllerModelTag", ",", "err", ")", "\n", "}", "\n", "return", "nil", ",", "mongo", ".", "MaybeUnauthorizedf", "(", "err", ",", "\"", "\"", ",", "args", ".", "ControllerModelTag", ".", "Id", "(", ")", ")", "\n", "}", "\n\n", "// State should only be Opened on behalf of a controller environ; all", "// other *States must be obtained via StatePool.", "if", "err", ":=", "st", ".", "start", "(", "args", ".", "ControllerTag", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "st", ",", "nil", "\n", "}" ]

[ "Open", "connects", "to", "the", "server", "with", "the", "given", "parameters", "waits", "for", "it", "to", "be", "initialized", "and", "returns", "a", "new", "State", "representing", "the", "model", "connected", "to", ".", "Open", "returns", "unauthorizedError", "if", "access", "is", "unauthorized", "." ]

[ "func", "NewMockProfileMachine", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockProfileMachine", "{", "mock", ":=", "&", "MockProfileMachine", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockProfileMachineMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockProfileMachine", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockProfileMachine", ")", "UpgradeCharmProfileCharmURL", "(", "arg0", "string", ")", "(", "string", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "string", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "UpgradeCharmProfileCharmURL", "mocks", "base", "method" ]