Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "(", "inst", "*", "azureInstance", ")", "Addresses", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "jujunetwork", ".", "Address", ",", "error", ")", "{", "addresses", ":=", "make", "(", "[", "]", "jujunetwork", ".", "Address", ",", "0", ",", "len", "(", "inst", ".", "networkInterfaces", ")", "+", "len", "(", "inst", ".", "publicIPAddresses", ")", ")", "\n", "for", "_", ",", "nic", ":=", "range", "inst", ".", "networkInterfaces", "{", "if", "nic", ".", "IPConfigurations", "==", "nil", "{", "continue", "\n", "}", "\n", "for", "_", ",", "ipConfiguration", ":=", "range", "*", "nic", ".", "IPConfigurations", "{", "privateIpAddress", ":=", "ipConfiguration", ".", "PrivateIPAddress", "\n", "if", "privateIpAddress", "==", "nil", "{", "continue", "\n", "}", "\n", "addresses", "=", "append", "(", "addresses", ",", "jujunetwork", ".", "NewScopedAddress", "(", "to", ".", "String", "(", "privateIpAddress", ")", ",", "jujunetwork", ".", "ScopeCloudLocal", ",", ")", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "pip", ":=", "range", "inst", ".", "publicIPAddresses", "{", "if", "pip", ".", "IPAddress", "==", "nil", "{", "continue", "\n", "}", "\n", "addresses", "=", "append", "(", "addresses", ",", "jujunetwork", ".", "NewScopedAddress", "(", "to", ".", "String", "(", "pip", ".", "IPAddress", ")", ",", "jujunetwork", ".", "ScopePublic", ",", ")", ")", "\n", "}", "\n", "return", "addresses", ",", "nil", "\n", "}" ]

[ "Addresses", "is", "specified", "in", "the", "Instance", "interface", "." ]

[ "func", "(", "inst", "*", "azureInstance", ")", "primaryNetworkAddress", "(", ")", "(", "jujunetwork", ".", "Address", ",", "error", ")", "{", "for", "_", ",", "nic", ":=", "range", "inst", ".", "networkInterfaces", "{", "if", "nic", ".", "IPConfigurations", "==", "nil", "{", "continue", "\n", "}", "\n", "for", "_", ",", "ipConfiguration", ":=", "range", "*", "nic", ".", "IPConfigurations", "{", "if", "ipConfiguration", ".", "Subnet", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "!", "to", ".", "Bool", "(", "ipConfiguration", ".", "Primary", ")", "{", "continue", "\n", "}", "\n", "privateIpAddress", ":=", "ipConfiguration", ".", "PrivateIPAddress", "\n", "if", "privateIpAddress", "==", "nil", "{", "continue", "\n", "}", "\n", "return", "jujunetwork", ".", "NewScopedAddress", "(", "to", ".", "String", "(", "privateIpAddress", ")", ",", "jujunetwork", ".", "ScopeCloudLocal", ",", ")", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "jujunetwork", ".", "Address", "{", "}", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}" ]

[ "primaryNetworkAddress", "returns", "the", "instance", "s", "primary", "jujunetwork", ".", "Address", "for", "the", "internal", "virtual", "network", ".", "This", "address", "is", "used", "to", "identify", "the", "machine", "in", "network", "security", "rules", "." ]

[ "func", "(", "inst", "*", "azureInstance", ")", "ClosePorts", "(", "ctx", "context", ".", "ProviderCallContext", ",", "machineId", "string", ",", "rules", "[", "]", "jujunetwork", ".", "IngressRule", ")", "error", "{", "securityRuleClient", ":=", "network", ".", "SecurityRulesClient", "{", "inst", ".", "env", ".", "network", "}", "\n", "securityGroupName", ":=", "internalSecurityGroupName", "\n\n", "// Delete rules one at a time; this is necessary to avoid trampling", "// on changes made by the provisioner.", "vmName", ":=", "resourceName", "(", "names", ".", "NewMachineTag", "(", "machineId", ")", ")", "\n", "prefix", ":=", "instanceNetworkSecurityRulePrefix", "(", "instance", ".", "Id", "(", "vmName", ")", ")", "\n", "sdkCtx", ":=", "stdcontext", ".", "Background", "(", ")", "\n\n", "singleSourceIngressRules", ":=", "explodeIngressRules", "(", "rules", ")", "\n", "for", "_", ",", "rule", ":=", "range", "singleSourceIngressRules", "{", "ruleName", ":=", "securityRuleName", "(", "prefix", ",", "rule", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "ruleName", ")", "\n", "future", ",", "err", ":=", "securityRuleClient", ".", "Delete", "(", "stdcontext", ".", "Background", "(", ")", ",", "inst", ".", "env", ".", "resourceGroup", ",", "securityGroupName", ",", "ruleName", ",", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "isNotFoundResponse", "(", "future", ".", "Response", "(", ")", ")", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "ruleName", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "err", "=", "future", ".", "WaitForCompletionRef", "(", "sdkCtx", ",", "securityRuleClient", ".", "Client", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "ruleName", ")", "\n", "}", "\n", "result", ",", "err", ":=", "future", ".", "Result", "(", "securityRuleClient", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "isNotFoundResult", "(", "result", ")", "{", "return", "errorutils", ".", "HandleCredentialError", "(", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "ruleName", ")", ",", "ctx", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ClosePorts", "is", "specified", "in", "the", "Instance", "interface", "." ]

[ "func", "securityRuleName", "(", "prefix", "string", ",", "rule", "jujunetwork", ".", "IngressRule", ")", "string", "{", "ruleName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "prefix", ",", "rule", ".", "Protocol", ",", "rule", ".", "FromPort", ")", "\n", "if", "rule", ".", "FromPort", "!=", "rule", ".", "ToPort", "{", "ruleName", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "rule", ".", "ToPort", ")", "\n", "}", "\n", "// The rule parameter must have a single source cidr.", "// Ensure the rule name can be a valid URL path component.", "cidr", ":=", "rule", ".", "SourceCIDRs", "[", "0", "]", "\n", "if", "cidr", "!=", "\"", "\"", "&&", "cidr", "!=", "\"", "\"", "{", "cidr", "=", "strings", ".", "Replace", "(", "cidr", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "cidr", "=", "strings", ".", "Replace", "(", "cidr", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "cidr", "=", "strings", ".", "Replace", "(", "cidr", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "ruleName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ruleName", ",", "cidr", ")", "\n", "}", "\n", "return", "ruleName", "\n", "}" ]

[ "securityRuleName", "returns", "the", "security", "rule", "name", "for", "the", "given", "ingress", "rule", "and", "prefix", "returned", "by", "instanceNetworkSecurityRulePrefix", "." ]

[ "func", "explodeIngressRules", "(", "inRules", "jujunetwork", ".", "IngressRuleSlice", ")", "jujunetwork", ".", "IngressRuleSlice", "{", "// If any rule has an empty source CIDR slice, a default", "// source value of \"*\" is used.", "var", "singleSourceIngressRules", "jujunetwork", ".", "IngressRuleSlice", "\n", "for", "_", ",", "rule", ":=", "range", "inRules", "{", "sourceCIDRs", ":=", "rule", ".", "SourceCIDRs", "\n", "if", "len", "(", "sourceCIDRs", ")", "==", "0", "{", "sourceCIDRs", "=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "}", "\n", "for", "_", ",", "sr", ":=", "range", "sourceCIDRs", "{", "r", ":=", "rule", "\n", "r", ".", "SourceCIDRs", "=", "[", "]", "string", "{", "sr", "}", "\n", "singleSourceIngressRules", "=", "append", "(", "singleSourceIngressRules", ",", "r", ")", "\n", "}", "\n", "}", "\n", "return", "singleSourceIngressRules", "\n", "}" ]

[ "explodeIngressRules", "creates", "a", "slice", "of", "ingress", "rules", "each", "rule", "in", "the", "result", "having", "a", "single", "source", "CIDR", ".", "The", "results", "contain", "a", "copy", "of", "each", "specified", "rule", "with", "each", "copy", "having", "one", "of", "the", "source", "CIDR", "values" ]

[ "func", "newDetectHardwareScript", "(", ")", "(", "string", ",", "error", ")", "{", "tmpl", ":=", "template", ".", "Must", "(", "template", ".", "New", "(", "\"", "\"", ")", ".", "Parse", "(", "detectHardware", ")", ")", "\n", "var", "in", "bytes", ".", "Buffer", "\n", "seriesMap", ":=", "series", ".", "WindowsVersions", "(", ")", "\n", "if", "err", ":=", "tmpl", ".", "Execute", "(", "&", "in", ",", "seriesMap", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "shell", ".", "NewPSEncodedCommand", "(", "in", ".", "String", "(", ")", ")", "\n", "}" ]

[ "newDetectHardwareScript", "will", "parse", "the", "detectHardware", "script", "and", "add", "into", "the", "powershell", "hastable", "the", "key", "val", "of", "the", "map", "returned", "from", "the", "WindowsVersions", "func", "from", "the", "series", "pkg", ".", "it", "will", "return", "the", "script", "wrapped", "into", "a", "safe", "powershell", "base64" ]

[ "func", "InitAdministratorUser", "(", "args", "*", "manual", ".", "ProvisionMachineArgs", ")", "error", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "args", ".", "Host", ",", "args", ".", "User", ")", "\n", "err", ":=", "args", ".", "WinRM", ".", "Client", ".", "Ping", "(", ")", "\n", "if", "err", "==", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "args", ".", "Host", ",", "args", ".", "User", ")", "\n", "return", "nil", "\n", "}", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "args", ".", "Host", ",", "args", ".", "User", ")", "\n", "if", "args", ".", "WinRM", ".", "Client", ",", "err", "=", "winrm", ".", "NewClient", "(", "winrm", ".", "ClientConfig", "{", "User", ":", "args", ".", "User", ",", "Host", ":", "args", ".", "Host", ",", "Timeout", ":", "25", "*", "time", ".", "Second", ",", "Password", ":", "winrm", ".", "TTYGetPasswd", ",", "Secure", ":", "false", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "args", ".", "Host", ",", "args", ".", "User", ")", "\n", "if", "err", "=", "args", ".", "WinRM", ".", "Client", ".", "Ping", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "args", ".", "Host", ")", "\n", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "defClient", ":=", "args", ".", "WinRM", ".", "Client", "\n", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "if", "args", ".", "WinRM", ".", "Client", ",", "err", "=", "enableCertAuth", "(", "args", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "args", ".", "WinRM", ".", "Client", "=", "defClient", "\n", "return", "nil", "\n", "}", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "args", ".", "Host", ",", "args", ".", "User", ")", "\n", "err", "=", "args", ".", "WinRM", ".", "Client", ".", "Ping", "(", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "args", ".", "WinRM", ".", "Client", "=", "defClient", "\n\n", "return", "nil", "\n\n", "}" ]

[ "InitAdministratorUser", "will", "initially", "attempt", "to", "login", "as", "the", "Administrator", "user", "using", "the", "secure", "client", "only", "if", "this", "is", "false", "then", "this", "will", "make", "a", "new", "attempt", "with", "the", "unsecure", "http", "client", "." ]

[ "func", "enableCertAuth", "(", "args", "*", "manual", ".", "ProvisionMachineArgs", ")", "(", "manual", ".", "WinrmClientAPI", ",", "error", ")", "{", "var", "stderr", "bytes", ".", "Buffer", "\n", "pass", ":=", "args", ".", "WinRM", ".", "Client", ".", "Password", "(", ")", "\n\n", "scripts", ",", "err", ":=", "bindInitScripts", "(", "pass", ",", "args", ".", "WinRM", ".", "Keys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "script", ":=", "range", "scripts", "{", "err", "=", "args", ".", "WinRM", ".", "Client", ".", "Run", "(", "script", ",", "args", ".", "Stdout", ",", "&", "stderr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "stderr", ".", "Len", "(", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "stderr", ".", "String", "(", ")", ",", ")", "\n", "}", "\n", "}", "\n\n", "cfg", ":=", "winrm", ".", "ClientConfig", "{", "User", ":", "args", ".", "User", ",", "Host", ":", "args", ".", "Host", ",", "Key", ":", "args", ".", "WinRM", ".", "Keys", ".", "ClientKey", "(", ")", ",", "Cert", ":", "args", ".", "WinRM", ".", "Keys", ".", "ClientCert", "(", ")", ",", "Timeout", ":", "25", "*", "time", ".", "Second", ",", "Secure", ":", "true", ",", "}", "\n\n", "caCert", ":=", "args", ".", "WinRM", ".", "Keys", ".", "CACert", "(", ")", "\n", "if", "caCert", "==", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "cfg", ".", "Insecure", "=", "true", "\n", "}", "else", "{", "cfg", ".", "CACert", "=", "caCert", "\n", "}", "\n\n", "return", "winrm", ".", "NewClient", "(", "cfg", ")", "\n", "}" ]

[ "enableCertAuth", "enables", "https", "cert", "auth", "interactions", "with", "the", "winrm", "listener", "and", "returns", "the", "client" ]

[ "func", "checkProvisioned", "(", "host", "string", ",", "cli", "manual", ".", "WinrmClientAPI", ")", "(", "bool", ",", "error", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "host", ")", "\n", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n\n", "// run the command trough winrm", "// this script detects if the jujud process, service is up and running", "script", ",", "err", ":=", "shell", ".", "NewPSEncodedCommand", "(", "detectJujudProcess", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// send the script to the windows machine", "if", "err", "=", "cli", ".", "Run", "(", "script", ",", "&", "stdout", ",", "&", "stderr", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "provisioned", ":=", "strings", ".", "Contains", "(", "stdout", ".", "String", "(", ")", ",", "\"", "\"", ")", "\n", "if", "stderr", ".", "Len", "(", ")", "!=", "0", "{", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "strings", ".", "TrimSpace", "(", "stderr", ".", "String", "(", ")", ")", ")", "\n", "}", "\n\n", "// if the script said yes", "if", "provisioned", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "host", ")", "\n", "}", "else", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "host", ")", "\n", "}", "\n\n", "return", "provisioned", ",", "err", "\n", "}" ]

[ "checkProvisioned", "checks", "if", "the", "machine", "is", "already", "provisioned", "or", "not", ".", "if", "it", "s", "already", "provisioned", "it", "will", "return", "true" ]

[ "func", "DetectSeriesAndHardwareCharacteristics", "(", "host", "string", ",", "cli", "manual", ".", "WinrmClientAPI", ")", "(", "hc", "instance", ".", "HardwareCharacteristics", ",", "series", "string", ",", "err", "error", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "host", ")", "\n", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n\n", "script", ",", "err", ":=", "newDetectHardwareScript", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "hc", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// send the script to the windows machine", "if", "err", "=", "cli", ".", "Run", "(", "script", ",", "&", "stdout", ",", "&", "stderr", ")", ";", "err", "!=", "nil", "{", "return", "hc", ",", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "stderr", ".", "Len", "(", ")", "!=", "0", "{", "return", "hc", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "strings", ".", "TrimSpace", "(", "stderr", ".", "String", "(", ")", ")", ")", "\n", "}", "\n\n", "info", ",", "err", ":=", "splitHardWareScript", "(", "stdout", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "hc", ",", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "series", "=", "strings", ".", "Replace", "(", "info", "[", "2", "]", ",", "\"", "\\r", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "if", "err", "=", "initHC", "(", "&", "hc", ",", "info", ")", ";", "err", "!=", "nil", "{", "return", "hc", ",", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "hc", ",", "series", ",", "nil", "\n", "}" ]

[ "DetectSeriesAndHardwareCharacteristics", "detects", "the", "windows", "OS", "series", "and", "hardware", "characteristics", "of", "the", "remote", "machine", "by", "connecting", "to", "the", "machine", "and", "executing", "a", "bash", "script", "." ]

[ "func", "splitHardWareScript", "(", "script", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "scr", ":=", "strings", ".", "Split", "(", "script", ",", "\"", "\\n", "\"", ")", "\n", "n", ":=", "len", "(", "scr", ")", "\n", "if", "n", "<", "3", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "script", ")", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "n", ";", "i", "++", "{", "scr", "[", "i", "]", "=", "strings", ".", "TrimSpace", "(", "scr", "[", "i", "]", ")", "\n", "}", "\n", "return", "scr", ",", "nil", "\n", "}" ]

[ "splitHardwareScript", "will", "split", "the", "result", "from", "the", "detectHardware", "powershell", "script", "to", "extract", "the", "information", "in", "a", "specific", "order", ".", "this", "will", "return", "a", "slice", "of", "string", "that", "will", "be", "used", "in", "conjunctions", "with", "the", "above", "function" ]

[ "func", "runProvisionScript", "(", "script", "string", ",", "cli", "manual", ".", "WinrmClientAPI", ",", "stdin", ",", "stderr", "io", ".", "Writer", ")", "(", "err", "error", ")", "{", "script64", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "[", "]", "byte", "(", "script", ")", ")", "\n", "input", ":=", "bytes", ".", "NewBufferString", "(", "script64", ")", "// make new buffer out of script", "\n", "// we must make sure to buffer the entire script", "// in a sequential write fashion first into a script", "// decouple the provisioning script into little 1024 byte chunks", "// we are doing this in order to append into a .ps1 file.", "var", "buf", "[", "1024", "]", "byte", "\n\n", "// if the file dosen't exist ,create it", "// if the file exists just clear/reset it", "script", ",", "err", "=", "shell", ".", "NewPSEncodedCommand", "(", "initChunk", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", "=", "cli", ".", "Run", "(", "script", ",", "stdin", ",", "stderr", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// sequential read.", "for", "input", ".", "Len", "(", ")", "!=", "0", "{", "n", ",", "err", ":=", "input", ".", "Read", "(", "buf", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "script", ",", "err", "=", "shell", ".", "NewPSEncodedCommand", "(", "fmt", ".", "Sprintf", "(", "saveChunk", ",", "string", "(", "buf", "[", ":", "n", "]", ")", ")", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", "=", "cli", ".", "Run", "(", "script", ",", "stdin", ",", "stderr", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "// after the sendAndSave script is successfully done", "// we must execute the newly writed script", "script", ",", "err", "=", "shell", ".", "NewPSEncodedCommand", "(", "runCmdProv", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "var", "outerr", "bytes", ".", "Buffer", "\n", "if", "err", "=", "cli", ".", "Run", "(", "script", ",", "stdin", ",", "&", "outerr", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "outerr", ".", "Len", "(", ")", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "strings", ".", "TrimSpace", "(", "outerr", ".", "String", "(", ")", ")", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "runProvisionScript", "runs", "the", "script", "generated", "by", "the", "provisioner", "the", "script", "can", "be", "big", "and", "the", "underlying", "protocol", "dosen", "t", "support", "long", "messages", "we", "need", "to", "send", "it", "into", "little", "chunks", "saving", "first", "into", "a", "file", "and", "then", "execute", "it", "." ]

[ "func", "ProvisioningScript", "(", "icfg", "*", "instancecfg", ".", "InstanceConfig", ")", "(", "string", ",", "error", ")", "{", "cloudcfg", ",", "err", ":=", "cloudinit", ".", "New", "(", "icfg", ".", "Series", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "udata", ",", "err", ":=", "cloudconfig", ".", "NewUserdataConfig", "(", "icfg", ",", "cloudcfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "udata", ".", "Configure", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "cloudcfg", ".", "RenderScript", "(", ")", "\n", "}" ]

[ "ProvisioningScript", "generates", "a", "powershell", "script", "that", "can", "be", "executed", "on", "a", "remote", "host", "to", "carry", "out", "the", "cloud", "-", "init", "configuration", "." ]

[ "func", "randomAdminPassword", "(", ")", "string", "{", "// We want at least one each of lower-alpha, upper-alpha, and digit.", "// Allocate 16 of each (randomly), and then the remaining characters", "// will be randomly chosen from the full set.", "validRunes", ":=", "append", "(", "utils", ".", "LowerAlpha", ",", "utils", ".", "Digits", "...", ")", "\n", "validRunes", "=", "append", "(", "validRunes", ",", "utils", ".", "UpperAlpha", "...", ")", "\n\n", "lowerAlpha", ":=", "utils", ".", "RandomString", "(", "16", ",", "utils", ".", "LowerAlpha", ")", "\n", "upperAlpha", ":=", "utils", ".", "RandomString", "(", "16", ",", "utils", ".", "UpperAlpha", ")", "\n", "digits", ":=", "utils", ".", "RandomString", "(", "16", ",", "utils", ".", "Digits", ")", "\n", "mixed", ":=", "utils", ".", "RandomString", "(", "16", ",", "validRunes", ")", "\n", "password", ":=", "[", "]", "rune", "(", "lowerAlpha", "+", "upperAlpha", "+", "digits", "+", "mixed", ")", "\n", "for", "i", ":=", "len", "(", "password", ")", "-", "1", ";", "i", ">=", "1", ";", "i", "--", "{", "j", ":=", "rand", ".", "Intn", "(", "i", "+", "1", ")", "\n", "password", "[", "i", "]", ",", "password", "[", "j", "]", "=", "password", "[", "j", "]", ",", "password", "[", "i", "]", "\n", "}", "\n", "return", "string", "(", "password", ")", "\n", "}" ]

[ "randomAdminPassword", "returns", "a", "random", "administrator", "password", "for", "Windows", "machines", "." ]

[ "func", "collectAPIVersions", "(", "ctx", "context", ".", "ProviderCallContext", ",", "sdkCtx", "stdcontext", ".", "Context", ",", "client", "resources", ".", "ProvidersClient", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "result", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n\n", "var", "res", "resources", ".", "ProviderListResultIterator", "\n", "res", ",", "err", ":=", "client", ".", "ListComplete", "(", "sdkCtx", ",", "nil", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "errorutils", ".", "HandleCredentialError", "(", "errors", ".", "Trace", "(", "err", ")", ",", "ctx", ")", "\n", "}", "\n", "for", ";", "res", ".", "NotDone", "(", ")", ";", "err", "=", "res", ".", "NextWithContext", "(", "sdkCtx", ")", "{", "if", "err", "!=", "nil", "{", "return", "map", "[", "string", "]", "string", "{", "}", ",", "errorutils", ".", "HandleCredentialError", "(", "errors", ".", "Trace", "(", "err", ")", ",", "ctx", ")", "\n", "}", "\n\n", "provider", ":=", "res", ".", "Value", "(", ")", "\n", "if", "provider", ".", "ResourceTypes", "==", "nil", "{", "continue", "\n", "}", "\n\n", "for", "_", ",", "resourceType", ":=", "range", "*", "provider", ".", "ResourceTypes", "{", "key", ":=", "to", ".", "String", "(", "provider", ".", "Namespace", ")", "+", "\"", "\"", "+", "to", ".", "String", "(", "resourceType", ".", "ResourceType", ")", "\n", "versions", ":=", "to", ".", "StringSlice", "(", "resourceType", ".", "APIVersions", ")", "\n", "if", "len", "(", "versions", ")", "==", "0", "{", "continue", "\n", "}", "\n", "// The versions are newest-first.", "result", "[", "key", "]", "=", "versions", "[", "0", "]", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "collectAPIVersions", "returns", "a", "map", "of", "the", "latest", "API", "version", "for", "each", "possible", "resource", "type", ".", "This", "is", "needed", "to", "use", "the", "Azure", "Resource", "Management", "API", "because", "the", "API", "version", "requested", "must", "match", "the", "type", "of", "the", "resource", "being", "manipulated", "through", "the", "API", "rather", "than", "the", "API", "version", "specified", "statically", "in", "the", "resource", "client", "code", "." ]

[ "func", "NewAPI", "(", "ctx", "facade", ".", "Context", ",", "getEnviron", "stateenvirons", ".", "NewEnvironFunc", ",", "getCAASBroker", "stateenvirons", ".", "NewCAASBrokerFunc", ",", "callCtx", "context", ".", "ProviderCallContext", ")", "(", "*", "API", ",", "error", ")", "{", "auth", ":=", "ctx", ".", "Auth", "(", ")", "\n", "st", ":=", "ctx", ".", "State", "(", ")", "\n", "if", "err", ":=", "checkAuth", "(", "auth", ",", "st", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "API", "{", "state", ":", "st", ",", "pool", ":", "ctx", ".", "StatePool", "(", ")", ",", "authorizer", ":", "auth", ",", "resources", ":", "ctx", ".", "Resources", "(", ")", ",", "presence", ":", "ctx", ".", "Presence", "(", ")", ",", "getClaimer", ":", "ctx", ".", "LeadershipClaimer", ",", "getEnviron", ":", "getEnviron", ",", "getCAASBroker", ":", "getCAASBroker", ",", "callContext", ":", "callCtx", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAPI", "returns", "a", "new", "API", ".", "Accepts", "a", "NewEnvironFunc", "and", "context", ".", "ProviderCallContext", "for", "testing", "purposes", "." ]

[ "func", "(", "api", "*", "API", ")", "Prechecks", "(", "model", "params", ".", "MigrationModelInfo", ")", "error", "{", "ownerTag", ",", "err", ":=", "names", ".", "ParseUserTag", "(", "model", ".", "OwnerTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "controllerState", ":=", "api", ".", "pool", ".", "SystemState", "(", ")", "\n", "// NOTE (thumper): it isn't clear to me why api.state would be different", "// from the controllerState as I had thought that the Precheck call was", "// on the controller model, in which case it should be the same as the", "// controllerState.", "backend", ",", "err", ":=", "migration", ".", "PrecheckShim", "(", "api", ".", "state", ",", "controllerState", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "migration", ".", "TargetPrecheck", "(", "backend", ",", "migration", ".", "PoolShim", "(", "api", ".", "pool", ")", ",", "coremigration", ".", "ModelInfo", "{", "UUID", ":", "model", ".", "UUID", ",", "Name", ":", "model", ".", "Name", ",", "Owner", ":", "ownerTag", ",", "AgentVersion", ":", "model", ".", "AgentVersion", ",", "ControllerAgentVersion", ":", "model", ".", "ControllerAgentVersion", ",", "}", ",", "api", ".", "presence", ".", "ModelPresence", "(", "controllerState", ".", "ModelUUID", "(", ")", ")", ",", ")", "\n", "}" ]

[ "Prechecks", "ensure", "that", "the", "target", "controller", "is", "ready", "to", "accept", "a", "model", "migration", "." ]

[ "func", "(", "api", "*", "API", ")", "Import", "(", "serialized", "params", ".", "SerializedModel", ")", "error", "{", "controller", ":=", "state", ".", "NewController", "(", "api", ".", "pool", ")", "\n", "_", ",", "st", ",", "err", ":=", "migration", ".", "ImportModel", "(", "controller", ",", "api", ".", "getClaimer", ",", "serialized", ".", "Bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "st", ".", "Close", "(", ")", "\n", "// TODO(mjs) - post import checks", "// NOTE(fwereade) - checks here would be sensible, but we will", "// also need to check after the binaries are imported too.", "return", "err", "\n", "}" ]

[ "Import", "takes", "a", "serialized", "Juju", "model", "deserializes", "it", "and", "recreates", "it", "in", "the", "receiving", "controller", "." ]

[ "func", "(", "api", "*", "API", ")", "Abort", "(", "args", "params", ".", "ModelArgs", ")", "error", "{", "model", ",", "releaseModel", ",", "err", ":=", "api", ".", "getImportingModel", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "releaseModel", "(", ")", "\n\n", "st", ",", "err", ":=", "api", ".", "pool", ".", "Get", "(", "model", ".", "UUID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "st", ".", "Release", "(", ")", "\n", "return", "st", ".", "RemoveImportingModelDocs", "(", ")", "\n", "}" ]

[ "Abort", "removes", "the", "specified", "model", "from", "the", "database", ".", "It", "is", "an", "error", "to", "attempt", "to", "Abort", "a", "model", "that", "has", "a", "migration", "mode", "other", "than", "importing", "." ]

[ "func", "(", "api", "*", "API", ")", "Activate", "(", "args", "params", ".", "ModelArgs", ")", "error", "{", "model", ",", "release", ",", "err", ":=", "api", ".", "getImportingModel", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "release", "(", ")", "\n\n", "if", "err", ":=", "model", ".", "SetStatus", "(", "status", ".", "StatusInfo", "{", "Status", ":", "status", ".", "Available", "}", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// TODO(fwereade) - need to validate binaries here.", "return", "model", ".", "SetMigrationMode", "(", "state", ".", "MigrationModeNone", ")", "\n", "}" ]

[ "Activate", "sets", "the", "migration", "mode", "of", "the", "model", "to", "none", "meaning", "it", "is", "ready", "for", "use", ".", "It", "is", "an", "error", "to", "attempt", "to", "Abort", "a", "model", "that", "has", "a", "migration", "mode", "other", "than", "importing", "." ]

[ "func", "CloudFromKubeConfig", "(", "reader", "io", ".", "Reader", ",", "cloudParams", "KubeCloudParams", ")", "(", "cloud", ".", "Cloud", ",", "cloud", ".", "Credential", ",", "string", ",", "error", ")", "{", "return", "newCloudCredentialFromKubeConfig", "(", "reader", ",", "cloudParams", ")", "\n", "}" ]

[ "CloudFromKubeConfig", "attempts", "to", "extract", "a", "cloud", "and", "credential", "details", "from", "the", "provided", "Kubeconfig", "." ]

[ "func", "ParseCloudRegion", "(", "cloudRegion", "string", ")", "(", "string", ",", "string", ",", "error", ")", "{", "fields", ":=", "strings", ".", "SplitN", "(", "cloudRegion", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "fields", ")", "!=", "2", "||", "fields", "[", "0", "]", "==", "\"", "\"", "||", "fields", "[", "1", "]", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "cloudRegion", ")", "\n", "}", "\n", "return", "fields", "[", "0", "]", ",", "fields", "[", "1", "]", ",", "nil", "\n", "}" ]

[ "ParseCloudRegion", "breaks", "apart", "a", "clusters", "cloud", "region", "." ]

[ "func", "BaseKubeCloudOpenParams", "(", "cloud", "cloud", ".", "Cloud", ",", "credential", "cloud", ".", "Credential", ")", "(", "environs", ".", "OpenParams", ",", "error", ")", "{", "// To get a k8s client, we need a config with minimal information.", "// It's not used unless operating on a real model but we need to supply it.", "uuid", ",", "err", ":=", "utils", ".", "NewUUID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "environs", ".", "OpenParams", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "attrs", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "config", ".", "NameKey", ":", "\"", "\"", ",", "config", ".", "TypeKey", ":", "\"", "\"", ",", "config", ".", "UUIDKey", ":", "uuid", ".", "String", "(", ")", ",", "}", "\n", "cfg", ",", "err", ":=", "config", ".", "New", "(", "config", ".", "NoDefaults", ",", "attrs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "environs", ".", "OpenParams", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "cloudSpec", ",", "err", ":=", "environs", ".", "MakeCloudSpec", "(", "cloud", ",", "\"", "\"", ",", "&", "credential", ")", "\n", "if", "err", "!=", "nil", "{", "return", "environs", ".", "OpenParams", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "openParams", ":=", "environs", ".", "OpenParams", "{", "Cloud", ":", "cloudSpec", ",", "Config", ":", "cfg", ",", "}", "\n", "return", "openParams", ",", "nil", "\n", "}" ]

[ "BaseKubeCloudOpenParams", "provides", "a", "basic", "OpenParams", "for", "a", "cluster" ]

[ "func", "(", "c", "*", "Client", ")", "GetMetrics", "(", "tags", "...", "string", ")", "(", "[", "]", "params", ".", "MetricResult", ",", "error", ")", "{", "entities", ":=", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "tags", ")", ")", "\n", "for", "i", ",", "tag", ":=", "range", "tags", "{", "entities", "[", "i", "]", "=", "params", ".", "Entity", "{", "Tag", ":", "tag", "}", "\n", "}", "\n", "p", ":=", "params", ".", "Entities", "{", "Entities", ":", "entities", "}", "\n", "results", ":=", "new", "(", "params", ".", "MetricResults", ")", "\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "p", ",", "results", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "results", ".", "OneError", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "metrics", ":=", "[", "]", "params", ".", "MetricResult", "{", "}", "\n", "for", "_", ",", "r", ":=", "range", "results", ".", "Results", "{", "metrics", "=", "append", "(", "metrics", ",", "r", ".", "Metrics", "...", ")", "\n", "}", "\n", "return", "metrics", ",", "nil", "\n", "}" ]

[ "GetMetrics", "will", "receive", "metrics", "collected", "by", "the", "given", "entity" ]

[ "func", "(", "c", "*", "Client", ")", "SetMeterStatus", "(", "tag", ",", "code", ",", "info", "string", ")", "error", "{", "args", ":=", "params", ".", "MeterStatusParams", "{", "Statuses", ":", "[", "]", "params", ".", "MeterStatusParam", "{", "{", "Tag", ":", "tag", ",", "Code", ":", "code", ",", "Info", ":", "info", ",", "}", ",", "}", ",", "}", "\n", "results", ":=", "new", "(", "params", ".", "ErrorResults", ")", "\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "results", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "results", ".", "OneError", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetMeterStatus", "will", "set", "the", "meter", "status", "on", "the", "given", "entity", "tag", "." ]

[ "func", "StorageName", "(", "vers", "version", ".", "Binary", ",", "stream", "string", ")", "string", "{", "return", "storagePrefix", "(", "stream", ")", "+", "vers", ".", "String", "(", ")", "+", "toolSuffix", "\n", "}" ]

[ "StorageName", "returns", "the", "name", "that", "is", "used", "to", "store", "and", "retrieve", "the", "given", "version", "of", "the", "juju", "tools", "." ]

[ "func", "ReadList", "(", "stor", "storage", ".", "StorageReader", ",", "toolsDir", "string", ",", "majorVersion", ",", "minorVersion", "int", ")", "(", "coretools", ".", "List", ",", "error", ")", "{", "if", "minorVersion", ">=", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "majorVersion", ",", "minorVersion", ")", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "majorVersion", ")", "\n", "}", "\n", "storagePrefix", ":=", "storagePrefix", "(", "toolsDir", ")", "\n", "names", ",", "err", ":=", "storage", ".", "List", "(", "stor", ",", "storagePrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "list", "coretools", ".", "List", "\n", "var", "foundAnyTools", "bool", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "name", "=", "filepath", ".", "ToSlash", "(", "name", ")", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "name", ",", "storagePrefix", ")", "||", "!", "strings", ".", "HasSuffix", "(", "name", ",", "toolSuffix", ")", "{", "continue", "\n", "}", "\n", "var", "t", "coretools", ".", "Tools", "\n", "vers", ":=", "name", "[", "len", "(", "storagePrefix", ")", ":", "len", "(", "name", ")", "-", "len", "(", "toolSuffix", ")", "]", "\n", "if", "t", ".", "Version", ",", "err", "=", "version", ".", "ParseBinary", "(", "vers", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "vers", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "foundAnyTools", "=", "true", "\n", "// If specified major version value supplied, major version must match.", "if", "majorVersion", ">=", "0", "&&", "t", ".", "Version", ".", "Major", "!=", "majorVersion", "{", "continue", "\n", "}", "\n", "// If specified minor version value supplied, minor version must match.", "if", "minorVersion", ">=", "0", "&&", "t", ".", "Version", ".", "Minor", "!=", "minorVersion", "{", "continue", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "vers", ")", "\n", "if", "t", ".", "URL", ",", "err", "=", "stor", ".", "URL", "(", "name", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "list", "=", "append", "(", "list", ",", "&", "t", ")", "\n", "// Older versions of Juju only know about ppc64, so add metadata for that arch.", "if", "t", ".", "Version", ".", "Arch", "==", "arch", ".", "PPC64EL", "{", "legacyPPC64Tools", ":=", "t", "\n", "legacyPPC64Tools", ".", "Version", ".", "Arch", "=", "arch", ".", "LEGACY_PPC64", "\n", "list", "=", "append", "(", "list", ",", "&", "legacyPPC64Tools", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "list", ")", "==", "0", "{", "if", "foundAnyTools", "{", "return", "nil", ",", "coretools", ".", "ErrNoMatches", "\n", "}", "\n", "return", "nil", ",", "ErrNoTools", "\n", "}", "\n", "return", "list", ",", "nil", "\n", "}" ]

[ "ReadList", "returns", "a", "List", "of", "the", "tools", "in", "store", "with", "the", "given", "major", ".", "minor", "version", ".", "If", "minorVersion", "=", "-", "1", "then", "only", "majorVersion", "is", "considered", ".", "If", "majorVersion", "is", "-", "1", "then", "all", "tools", "tarballs", "are", "used", ".", "If", "store", "contains", "no", "such", "tools", "it", "returns", "ErrNoMatches", "." ]

[ "func", "NewHTTPDownloadRequest", "(", "resourceName", "string", ")", "(", "*", "http", ".", "Request", ",", "error", ")", "{", "return", "http", ".", "NewRequest", "(", "\"", "\"", ",", "\"", "\"", "+", "resourceName", ",", "nil", ")", "\n", "}" ]

[ "NewHTTPDownloadRequest", "creates", "a", "new", "HTTP", "download", "request", "for", "the", "given", "resource", ".", "Intended", "for", "use", "on", "the", "client", "side", "." ]

[ "func", "NewZone", "(", "name", ",", "status", ",", "state", ",", "replacement", "string", ")", "AvailabilityZone", "{", "zone", ":=", "&", "compute", ".", "Zone", "{", "Name", ":", "name", ",", "Status", ":", "status", ",", "}", "\n", "if", "state", "!=", "\"", "\"", "{", "zone", ".", "Deprecated", "=", "&", "compute", ".", "DeprecationStatus", "{", "State", ":", "state", ",", "Replacement", ":", "replacement", ",", "}", "\n", "}", "\n", "return", "AvailabilityZone", "{", "zone", ":", "zone", "}", "\n", "}" ]

[ "NewZone", "build", "an", "availability", "zone", "from", "the", "provided", "name", "status", "state", "and", "replacement", "and", "returns", "it", "." ]

[ "func", "(", "z", "AvailabilityZone", ")", "Deprecated", "(", ")", "bool", "{", "deprecated", ":=", "z", ".", "zone", ".", "Deprecated", "!=", "nil", "\n", "if", "deprecated", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "z", ".", "Name", "(", ")", ",", "z", ".", "zone", ".", "Deprecated", ".", "State", ")", "\n", "if", "z", ".", "zone", ".", "Deprecated", ".", "Replacement", "!=", "\"", "\"", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "z", ".", "zone", ".", "Deprecated", ".", "Replacement", ",", "z", ".", "Name", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "deprecated", "\n", "}" ]

[ "Deprecated", "returns", "true", "if", "the", "zone", "has", "been", "deprecated", "." ]

[ "func", "(", "st", "*", "State", ")", "IsMaster", "(", ")", "(", "bool", ",", "error", ")", "{", "var", "results", "params", ".", "IsMasterResult", "\n", "err", ":=", "st", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "results", ")", "\n", "return", "results", ".", "Master", ",", "err", "\n", "}" ]

[ "IsMaster", "reports", "whether", "the", "connected", "machine", "agent", "lives", "at", "the", "same", "network", "address", "as", "the", "primary", "mongo", "server", "for", "the", "replica", "set", ".", "This", "call", "will", "return", "an", "error", "if", "the", "connected", "agent", "is", "not", "a", "machine", "agent", "with", "model", "-", "manager", "privileges", "." ]

[ "func", "(", "m", "*", "Entity", ")", "ClearReboot", "(", ")", "error", "{", "var", "result", "params", ".", "ErrorResults", "\n", "args", ":=", "params", ".", "SetStatus", "{", "Entities", ":", "[", "]", "params", ".", "EntityStatusArgs", "{", "{", "Tag", ":", "m", ".", "tag", ".", "String", "(", ")", "}", ",", "}", ",", "}", "\n", "err", ":=", "m", ".", "st", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "result", ".", "OneError", "(", ")", "\n", "}" ]

[ "ClearReboot", "clears", "the", "reboot", "flag", "of", "the", "machine", "." ]

[ "func", "NewStateAPI", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "ExternalControllerUpdaterAPI", ",", "error", ")", "{", "return", "NewAPI", "(", "ctx", ".", "Auth", "(", ")", ",", "ctx", ".", "Resources", "(", ")", ",", "state", ".", "NewExternalControllers", "(", "ctx", ".", "State", "(", ")", ")", ",", ")", "\n", "}" ]

[ "NewStateAPI", "creates", "a", "new", "server", "-", "side", "CrossModelRelationsAPI", "API", "facade", "backed", "by", "global", "state", "." ]

[ "func", "NewAPI", "(", "auth", "facade", ".", "Authorizer", ",", "resources", "facade", ".", "Resources", ",", "externalControllers", "state", ".", "ExternalControllers", ",", ")", "(", "*", "ExternalControllerUpdaterAPI", ",", "error", ")", "{", "if", "!", "auth", ".", "AuthController", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "&", "ExternalControllerUpdaterAPI", "{", "externalControllers", ",", "resources", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAPI", "creates", "a", "new", "server", "-", "side", "CrossModelRelationsAPI", "API", "facade", "backed", "by", "the", "given", "interfaces", "." ]

[ "func", "(", "api", "*", "ExternalControllerUpdaterAPI", ")", "WatchExternalControllers", "(", ")", "(", "params", ".", "StringsWatchResults", ",", "error", ")", "{", "w", ":=", "api", ".", "externalControllers", ".", "Watch", "(", ")", "\n", "changes", ",", "ok", ":=", "<-", "w", ".", "Changes", "(", ")", "\n", "if", "!", "ok", "{", "return", "params", ".", "StringsWatchResults", "{", "[", "]", "params", ".", "StringsWatchResult", "{", "{", "Error", ":", "common", ".", "ServerError", "(", "watcher", ".", "EnsureErr", "(", "w", ")", ")", ",", "}", "}", ",", "}", ",", "nil", "\n", "}", "\n", "return", "params", ".", "StringsWatchResults", "{", "[", "]", "params", ".", "StringsWatchResult", "{", "{", "StringsWatcherId", ":", "api", ".", "resources", ".", "Register", "(", "w", ")", ",", "Changes", ":", "changes", ",", "}", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "WatchExternalControllers", "watches", "for", "the", "addition", "and", "removal", "of", "external", "controller", "records", "to", "the", "local", "controller", "s", "database", "." ]

[ "func", "(", "s", "*", "ExternalControllerUpdaterAPI", ")", "ExternalControllerInfo", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "ExternalControllerInfoResults", ",", "error", ")", "{", "result", ":=", "params", ".", "ExternalControllerInfoResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ExternalControllerInfoResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "controllerTag", ",", "err", ":=", "names", ".", "ParseControllerTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "controller", ",", "err", ":=", "s", ".", "externalControllers", ".", "Controller", "(", "controllerTag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "info", ":=", "controller", ".", "ControllerInfo", "(", ")", "\n", "result", ".", "Results", "[", "i", "]", ".", "Result", "=", "&", "params", ".", "ExternalControllerInfo", "{", "ControllerTag", ":", "controllerTag", ".", "String", "(", ")", ",", "Alias", ":", "info", ".", "Alias", ",", "Addrs", ":", "info", ".", "Addrs", ",", "CACert", ":", "info", ".", "CACert", ",", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "ExternalControllerInfo", "returns", "the", "info", "for", "the", "specified", "external", "controllers", "." ]

[ "func", "(", "s", "*", "ExternalControllerUpdaterAPI", ")", "SetExternalControllerInfo", "(", "args", "params", ".", "SetExternalControllersInfoParams", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "result", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "Controllers", ")", ")", ",", "}", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Controllers", "{", "controllerTag", ",", "err", ":=", "names", ".", "ParseControllerTag", "(", "arg", ".", "Info", ".", "ControllerTag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "_", ",", "err", ":=", "s", ".", "externalControllers", ".", "Save", "(", "crossmodel", ".", "ControllerInfo", "{", "ControllerTag", ":", "controllerTag", ",", "Alias", ":", "arg", ".", "Info", ".", "Alias", ",", "Addrs", ":", "arg", ".", "Info", ".", "Addrs", ",", "CACert", ":", "arg", ".", "Info", ".", "CACert", ",", "}", ")", ";", "err", "!=", "nil", "{", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "SetExternalControllerInfo", "saves", "the", "info", "for", "the", "specified", "external", "controllers", "." ]

[ "func", "(", "c", "Config", ")", "Validate", "(", ")", "error", "{", "if", "c", ".", "Name", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "string", "(", "c", ".", "ContainerType", ")", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "APICaller", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "AgentConfig", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "MachineTag", ".", "Id", "(", ")", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "MachineLock", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "GetNetConfig", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "the", "instance", "broker", "configuration", "." ]

[ "func", "New", "(", "config", "Config", ")", "(", "environs", ".", "InstanceBroker", ",", "error", ")", "{", "if", "err", ":=", "config", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "manager", ",", "err", ":=", "factory", ".", "NewContainerManager", "(", "config", ".", "ContainerType", ",", "config", ".", "ManagerConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "var", "newBroker", "ContainerBrokerFunc", "\n", "switch", "config", ".", "ContainerType", "{", "case", "instance", ".", "KVM", ":", "newBroker", "=", "NewKVMBroker", "\n", "case", "instance", ".", "LXD", ":", "newBroker", "=", "NewLXDBroker", "\n", "default", ":", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "config", ".", "ContainerType", ")", "\n", "}", "\n\n", "broker", ",", "err", ":=", "newBroker", "(", "prepareHost", "(", "config", ")", ",", "config", ".", "APICaller", ",", "manager", ",", "config", ".", "AgentConfig", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "config", ".", "ContainerType", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "broker", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "new", "InstanceBroker", "from", "the", "Config" ]

[ "func", "ConfigureAvailabilityZone", "(", "managerConfig", "container", ".", "ManagerConfig", ",", "machineZone", "AvailabilityZoner", ")", "(", "container", ".", "ManagerConfig", ",", "error", ")", "{", "availabilityZone", ",", "err", ":=", "machineZone", ".", "AvailabilityZone", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "managerConfig", "[", "container", ".", "ConfigAvailabilityZone", "]", "=", "availabilityZone", "\n\n", "return", "managerConfig", ",", "nil", "\n", "}" ]

[ "ConfigureAvailabilityZone", "reads", "the", "availability", "zone", "from", "the", "machine", "and", "adds", "the", "resulting", "information", "to", "the", "the", "manager", "config", "." ]

[ "func", "getActionTagsByPrefix", "(", "api", "APIClient", ",", "prefix", "string", ")", "(", "[", "]", "names", ".", "ActionTag", ",", "error", ")", "{", "results", ":=", "[", "]", "names", ".", "ActionTag", "{", "}", "\n\n", "tags", ",", "err", ":=", "api", ".", "FindActionTagsByPrefix", "(", "params", ".", "FindTags", "{", "Prefixes", ":", "[", "]", "string", "{", "prefix", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "results", ",", "err", "\n", "}", "\n\n", "matches", ",", "ok", ":=", "tags", ".", "Matches", "[", "prefix", "]", "\n", "if", "!", "ok", "||", "len", "(", "matches", ")", "<", "1", "{", "return", "results", ",", "nil", "\n", "}", "\n\n", "results", ",", "rejects", ":=", "getActionTags", "(", "matches", ")", "\n", "if", "len", "(", "rejects", ")", ">", "0", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "prefix", ",", "rejects", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "getActionTagByPrefix", "uses", "the", "APIClient", "to", "get", "all", "ActionTags", "matching", "a", "prefix", "." ]

[ "func", "getActionTagByPrefix", "(", "api", "APIClient", ",", "prefix", "string", ")", "(", "names", ".", "ActionTag", ",", "error", ")", "{", "tag", ":=", "names", ".", "ActionTag", "{", "}", "\n", "actiontags", ",", "err", ":=", "getActionTagsByPrefix", "(", "api", ",", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tag", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "actiontags", ")", "<", "1", "{", "return", "tag", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "prefix", ")", "\n", "}", "\n\n", "if", "len", "(", "actiontags", ")", ">", "1", "{", "return", "tag", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "prefix", ",", "actiontags", ")", "\n", "}", "\n\n", "return", "actiontags", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "getActionTagByPrefix", "uses", "the", "APIClient", "to", "get", "an", "ActionTag", "from", "a", "prefix", "." ]

[ "func", "getActionTags", "(", "entities", "[", "]", "params", ".", "Entity", ")", "(", "good", "[", "]", "names", ".", "ActionTag", ",", "bad", "[", "]", "string", ")", "{", "for", "_", ",", "entity", ":=", "range", "entities", "{", "if", "tag", ",", "err", ":=", "entityToActionTag", "(", "entity", ")", ";", "err", "!=", "nil", "{", "bad", "=", "append", "(", "bad", ",", "entity", ".", "Tag", ")", "\n", "}", "else", "{", "good", "=", "append", "(", "good", ",", "tag", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "getActionTags", "converts", "a", "slice", "of", "params", ".", "Entity", "to", "a", "slice", "of", "names", ".", "ActionTag", "and", "also", "populates", "a", "slice", "of", "strings", "for", "the", "params", ".", "Entity", ".", "Tag", "that", "are", "not", "a", "valid", "names", ".", "ActionTag", "." ]

[ "func", "entityToActionTag", "(", "entity", "params", ".", "Entity", ")", "(", "names", ".", "ActionTag", ",", "error", ")", "{", "return", "names", ".", "ParseActionTag", "(", "entity", ".", "Tag", ")", "\n", "}" ]

[ "entityToActionTag", "converts", "the", "params", ".", "Entity", "type", "to", "a", "names", ".", "ActionTag" ]

[ "func", "(", "i", "*", "iscsiConnectionInfo", ")", "sessionBase", "(", "deviceName", "string", ")", "(", "string", ",", "error", ")", "{", "lnkPath", ":=", "filepath", ".", "Join", "(", "sysfsBlock", ",", "deviceName", ")", "\n", "lnkRealPath", ",", "err", ":=", "os", ".", "Readlink", "(", "lnkPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "fullPath", ",", "err", ":=", "filepath", ".", "Abs", "(", "filepath", ".", "Join", "(", "sysfsBlock", ",", "lnkRealPath", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "segments", ":=", "strings", ".", "SplitN", "(", "fullPath", "[", "1", ":", "]", ",", "\"", "\"", ",", "-", "1", ")", "\n", "if", "len", "(", "segments", ")", "!=", "9", "{", "// iscsi block devices look like:", "// /sys/devices/platform/host2/session1/target2:0:0/2:0:0:1/block/sda", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "filepath", ".", "Join", "(", "sysfsiSCSIHost", ",", "segments", "[", "3", "]", ")", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "sessionPath", ":=", "filepath", ".", "Join", "(", "sysfsiSCSISession", ",", "segments", "[", "4", "]", ")", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "sessionPath", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "sessionPath", ",", "nil", "\n", "}" ]

[ "sessionBase", "returns", "the", "iSCSI", "sysfs", "session", "folder" ]

[ "func", "(", "i", "*", "iscsiConnectionInfo", ")", "addTarget", "(", ")", "error", "{", "newNodeParams", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "i", ".", "iqn", ",", "\"", "\"", ",", "i", ".", "portal", "(", ")", "}", "\n", "result", ",", "err", ":=", "runCommand", "(", "newNodeParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "result", ".", "Stderr", ")", "\n", "}", "\n\n", "startupParams", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "i", ".", "iqn", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "result", ",", "err", "=", "runCommand", "(", "startupParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "result", ".", "Stderr", ")", "\n", "}", "\n\n", "if", "i", ".", "chapSecret", "!=", "\"", "\"", "&&", "i", ".", "chapUser", "!=", "\"", "\"", "{", "authModeParams", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "i", ".", "iqn", ",", "\"", "\"", ",", "i", ".", "portal", "(", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "result", ",", "err", "=", "runCommand", "(", "authModeParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "result", ".", "Stderr", ")", "\n", "}", "\n", "usernameParams", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "i", ".", "iqn", ",", "\"", "\"", ",", "i", ".", "portal", "(", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "i", ".", "chapUser", ",", "}", "\n", "result", ",", "err", "=", "runCommand", "(", "usernameParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "result", ".", "Stderr", ")", "\n", "}", "\n", "passwordParams", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "i", ".", "iqn", ",", "\"", "\"", ",", "i", ".", "portal", "(", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "i", ".", "chapSecret", ",", "}", "\n", "result", ",", "err", "=", "runCommand", "(", "passwordParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "result", ".", "Stderr", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "addTarget", "adds", "the", "iscsi", "target", "config" ]

[ "func", "scheduleOperations", "(", "ctx", "*", "context", ",", "ops", "...", "scheduleOp", ")", "{", "if", "len", "(", "ops", ")", "==", "0", "{", "return", "\n", "}", "\n", "now", ":=", "ctx", ".", "config", ".", "Clock", ".", "Now", "(", ")", "\n", "for", "_", ",", "op", ":=", "range", "ops", "{", "k", ":=", "op", ".", "key", "(", ")", "\n", "d", ":=", "op", ".", "delay", "(", ")", "\n", "ctx", ".", "schedule", ".", "Add", "(", "k", ",", "op", ",", "now", ".", "Add", "(", "d", ")", ")", "\n", "}", "\n", "}" ]

[ "scheduleOperations", "schedules", "the", "given", "operations", "by", "calculating", "the", "current", "time", "once", "and", "then", "adding", "each", "operation", "s", "delay", "to", "that", "time", ".", "By", "calculating", "the", "current", "time", "once", "we", "guarantee", "that", "operations", "with", "the", "same", "delay", "will", "be", "batched", "together", "." ]

[ "func", "(", "c", "environProviderCredentials", ")", "DetectCredentials", "(", ")", "(", "*", "cloud", ".", "CloudCredential", ",", "error", ")", "{", "// Attempt to get accounts from az.", "accounts", ",", "err", ":=", "c", ".", "azureCLI", ".", "ListAccounts", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "accounts", ")", "<", "1", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "clouds", ",", "err", ":=", "c", ".", "azureCLI", ".", "ListClouds", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "cloudMap", ":=", "make", "(", "map", "[", "string", "]", "azurecli", ".", "Cloud", ",", "len", "(", "clouds", ")", ")", "\n", "for", "_", ",", "cloud", ":=", "range", "clouds", "{", "cloudMap", "[", "cloud", ".", "Name", "]", "=", "cloud", "\n", "}", "\n", "var", "defaultCredential", "string", "\n", "authCredentials", ":=", "make", "(", "map", "[", "string", "]", "cloud", ".", "Credential", ")", "\n", "for", "i", ",", "acc", ":=", "range", "accounts", "{", "cloudInfo", ",", "ok", ":=", "cloudMap", "[", "acc", ".", "CloudName", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "cred", ",", "err", ":=", "c", ".", "accountCredential", "(", "acc", ",", "cloudInfo", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "acc", ".", "Name", ",", "err", ")", "\n", "if", "i", "==", "0", "{", "// Assume that if this fails the first", "// time then it will always fail and", "// don't attempt to create any further", "// credentials.", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "cred", ".", "Label", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cloudInfo", ".", "Name", ",", "acc", ".", "Name", ")", "\n", "authCredentials", "[", "acc", ".", "Name", "]", "=", "cred", "\n", "if", "acc", ".", "IsDefault", "{", "defaultCredential", "=", "acc", ".", "Name", "\n", "}", "\n", "}", "\n", "if", "len", "(", "authCredentials", ")", "<", "1", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "cloud", ".", "CloudCredential", "{", "DefaultCredential", ":", "defaultCredential", ",", "AuthCredentials", ":", "authCredentials", ",", "}", ",", "nil", "\n", "}" ]

[ "DetectCredentials", "is", "part", "of", "the", "environs", ".", "ProviderCredentials", "interface", ".", "It", "attempts", "to", "detect", "subscription", "IDs", "from", "accounts", "configured", "in", "the", "Azure", "CLI", "." ]

[ "func", "NewMachineAgentCmd", "(", "ctx", "*", "cmd", ".", "Context", ",", "machineAgentFactory", "machineAgentFactoryFnType", ",", "agentInitializer", "AgentInitializer", ",", "configFetcher", "AgentConfigWriter", ",", ")", "cmd", ".", "Command", "{", "return", "&", "machineAgentCmd", "{", "ctx", ":", "ctx", ",", "machineAgentFactory", ":", "machineAgentFactory", ",", "agentInitializer", ":", "agentInitializer", ",", "currentConfig", ":", "configFetcher", ",", "}", "\n", "}" ]

[ "NewMachineAgentCmd", "creates", "a", "Command", "which", "handles", "parsing", "command", "-", "line", "arguments", "and", "instantiating", "and", "running", "a", "MachineAgent", "." ]

[ "func", "(", "a", "*", "machineAgentCmd", ")", "Init", "(", "args", "[", "]", "string", ")", "error", "{", "if", "!", "names", ".", "IsValidMachine", "(", "a", ".", "machineId", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "a", ".", "agentInitializer", ".", "CheckArgs", "(", "args", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Due to changes in the logging, and needing to care about old", "// models that have been upgraded, we need to explicitly remove the", "// file writer if one has been added, otherwise we will get duplicate", "// lines of all logging in the log file.", "loggo", ".", "RemoveWriter", "(", "\"", "\"", ")", "\n\n", "if", "a", ".", "logToStdErr", "{", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "currentConfig", ".", "ReadConfig", "(", "a", ".", "tag", "(", ")", ".", "String", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "config", ":=", "a", ".", "currentConfig", ".", "CurrentConfig", "(", ")", "\n", "// the context's stderr is set as the loggo writer in github.com/juju/cmd/logging.go", "a", ".", "ctx", ".", "Stderr", "=", "&", "lumberjack", ".", "Logger", "{", "Filename", ":", "agent", ".", "LogFilename", "(", "config", ")", ",", "MaxSize", ":", "300", ",", "// megabytes", "MaxBackups", ":", "2", ",", "Compress", ":", "true", ",", "}", "\n", "return", "nil", "\n", "}" ]

[ "Init", "is", "called", "by", "the", "cmd", "system", "to", "initialize", "the", "structure", "for", "running", "." ]

[ "func", "(", "a", "*", "machineAgentCmd", ")", "Run", "(", "c", "*", "cmd", ".", "Context", ")", "error", "{", "config", ":=", "a", ".", "currentConfig", ".", "CurrentConfig", "(", ")", "\n", "isCaasMachineAgent", ":=", "config", ".", "Value", "(", "agent", ".", "ProviderType", ")", "==", "k8sprovider", ".", "CAASProviderType", "\n", "machineAgent", ",", "err", ":=", "a", ".", "machineAgentFactory", "(", "a", ".", "machineId", ",", "isCaasMachineAgent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "machineAgent", ".", "Run", "(", "c", ")", "\n", "}" ]

[ "Run", "instantiates", "a", "MachineAgent", "and", "runs", "it", "." ]

[ "func", "(", "a", "*", "machineAgentCmd", ")", "SetFlags", "(", "f", "*", "gnuflag", ".", "FlagSet", ")", "{", "a", ".", "agentInitializer", ".", "AddFlags", "(", "f", ")", "\n", "f", ".", "StringVar", "(", "&", "a", ".", "machineId", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}" ]

[ "SetFlags", "adds", "the", "requisite", "flags", "to", "run", "this", "command", "." ]

[ "func", "MachineAgentFactoryFn", "(", "agentConfWriter", "AgentConfigWriter", ",", "bufferedLogger", "*", "logsender", ".", "BufferedLogWriter", ",", "newIntrospectionSocketName", "func", "(", "names", ".", "Tag", ")", "string", ",", "preUpgradeSteps", "upgrades", ".", "PreUpgradeStepsFunc", ",", "rootDir", "string", ",", ")", "machineAgentFactoryFnType", "{", "return", "func", "(", "machineId", "string", ",", "isCaasMachineAgent", "bool", ")", "(", "*", "MachineAgent", ",", "error", ")", "{", "return", "NewMachineAgent", "(", "machineId", ",", "agentConfWriter", ",", "bufferedLogger", ",", "worker", ".", "NewRunner", "(", "worker", ".", "RunnerParams", "{", "IsFatal", ":", "cmdutil", ".", "IsFatal", ",", "MoreImportant", ":", "cmdutil", ".", "MoreImportant", ",", "RestartDelay", ":", "jworker", ".", "RestartDelay", ",", "}", ")", ",", "looputil", ".", "NewLoopDeviceManager", "(", ")", ",", "newIntrospectionSocketName", ",", "preUpgradeSteps", ",", "rootDir", ",", "isCaasMachineAgent", ",", ")", "\n", "}", "\n", "}" ]

[ "MachineAgentFactoryFn", "returns", "a", "function", "which", "instantiates", "a", "MachineAgent", "given", "a", "machineId", "." ]

[ "func", "NewMachineAgent", "(", "machineId", "string", ",", "agentConfWriter", "AgentConfigWriter", ",", "bufferedLogger", "*", "logsender", ".", "BufferedLogWriter", ",", "runner", "*", "worker", ".", "Runner", ",", "loopDeviceManager", "looputil", ".", "LoopDeviceManager", ",", "newIntrospectionSocketName", "func", "(", "names", ".", "Tag", ")", "string", ",", "preUpgradeSteps", "upgrades", ".", "PreUpgradeStepsFunc", ",", "rootDir", "string", ",", "isCaasMachineAgent", "bool", ",", ")", "(", "*", "MachineAgent", ",", "error", ")", "{", "prometheusRegistry", ",", "err", ":=", "newPrometheusRegistry", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "a", ":=", "&", "MachineAgent", "{", "machineId", ":", "machineId", ",", "AgentConfigWriter", ":", "agentConfWriter", ",", "configChangedVal", ":", "voyeur", ".", "NewValue", "(", "true", ")", ",", "bufferedLogger", ":", "bufferedLogger", ",", "workersStarted", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "dead", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "runner", ":", "runner", ",", "rootDir", ":", "rootDir", ",", "initialUpgradeCheckComplete", ":", "gate", ".", "NewLock", "(", ")", ",", "loopDeviceManager", ":", "loopDeviceManager", ",", "newIntrospectionSocketName", ":", "newIntrospectionSocketName", ",", "prometheusRegistry", ":", "prometheusRegistry", ",", "mongoTxnCollector", ":", "mongometrics", ".", "NewTxnCollector", "(", ")", ",", "mongoDialCollector", ":", "mongometrics", ".", "NewDialCollector", "(", ")", ",", "preUpgradeSteps", ":", "preUpgradeSteps", ",", "isCaasMachineAgent", ":", "isCaasMachineAgent", ",", "}", "\n", "return", "a", ",", "nil", "\n", "}" ]

[ "NewMachineAgent", "instantiates", "a", "new", "MachineAgent", "." ]

[ "func", "upgradeCertificateDNSNames", "(", "config", "agent", ".", "ConfigSetter", ")", "error", "{", "si", ",", "ok", ":=", "config", ".", "StateServingInfo", "(", ")", "\n", "if", "!", "ok", "||", "si", ".", "CAPrivateKey", "==", "\"", "\"", "{", "// No certificate information exists yet, nothing to do.", "return", "nil", "\n", "}", "\n\n", "// Validate the current certificate and private key pair, and then", "// extract the current DNS names from the certificate. If the", "// certificate validation fails, or it does not contain the DNS", "// names we require, we will generate a new one.", "var", "dnsNames", "set", ".", "Strings", "\n", "serverCert", ",", "_", ",", "err", ":=", "utilscert", ".", "ParseCertAndKey", "(", "si", ".", "Cert", ",", "si", ".", "PrivateKey", ")", "\n", "if", "err", "!=", "nil", "{", "// The certificate is invalid, so create a new one.", "logger", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "dnsNames", "=", "set", ".", "NewStrings", "(", ")", "\n", "}", "else", "{", "dnsNames", "=", "set", ".", "NewStrings", "(", "serverCert", ".", "DNSNames", "...", ")", "\n", "}", "\n\n", "update", ":=", "false", "\n", "requiredDNSNames", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "for", "_", ",", "dnsName", ":=", "range", "requiredDNSNames", "{", "if", "dnsNames", ".", "Contains", "(", "dnsName", ")", "{", "continue", "\n", "}", "\n", "dnsNames", ".", "Add", "(", "dnsName", ")", "\n", "update", "=", "true", "\n", "}", "\n", "if", "!", "update", "{", "return", "nil", "\n", "}", "\n\n", "// Write a new certificate to the mongo pem and agent config files.", "si", ".", "Cert", ",", "si", ".", "PrivateKey", ",", "err", "=", "cert", ".", "NewDefaultServer", "(", "config", ".", "CACert", "(", ")", ",", "si", ".", "CAPrivateKey", ",", "dnsNames", ".", "Values", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "mongo", ".", "UpdateSSLKey", "(", "config", ".", "DataDir", "(", ")", ",", "si", ".", "Cert", ",", "si", ".", "PrivateKey", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "config", ".", "SetStateServingInfo", "(", "si", ")", "\n", "return", "nil", "\n", "}" ]

[ "upgradeCertificateDNSNames", "ensure", "that", "the", "controller", "certificate", "recorded", "in", "the", "agent", "config", "and", "also", "mongo", "server", ".", "pem", "contains", "the", "DNSNames", "entries", "required", "by", "Juju", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "Run", "(", "*", "cmd", ".", "Context", ")", "(", "err", "error", ")", "{", "defer", "a", ".", "Done", "(", "err", ")", "\n", "useMultipleCPUs", "(", ")", "\n", "if", "err", ":=", "a", ".", "ReadConfig", "(", "a", ".", "Tag", "(", ")", ".", "String", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "setupAgentLogging", "(", "a", ".", "CurrentConfig", "(", ")", ")", "\n\n", "if", "err", ":=", "introspection", ".", "WriteProfileFunctions", "(", ")", ";", "err", "!=", "nil", "{", "// This isn't fatal, just annoying.", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// When the API server and peergrouper have manifolds, they can", "// have dependencies on a central hub worker.", "a", ".", "centralHub", "=", "centralhub", ".", "New", "(", "a", ".", "Tag", "(", ")", ".", "(", "names", ".", "MachineTag", ")", ")", "\n\n", "// Before doing anything else, we need to make sure the certificate generated for", "// use by mongo to validate controller connections is correct. This needs to be done", "// before any possible restart of the mongo service.", "// See bug http://pad.lv/1434680", "if", "err", ":=", "a", ".", "AgentConfigWriter", ".", "ChangeConfig", "(", "upgradeCertificateDNSNames", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// moved from NewMachineAgent here because the agent config could not be ready yet there.", "if", "err", ":=", "a", ".", "registerPrometheusCollectors", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "agentConfig", ":=", "a", ".", "CurrentConfig", "(", ")", "\n", "agentName", ":=", "a", ".", "Tag", "(", ")", ".", "String", "(", ")", "\n", "machineLock", ",", "err", ":=", "machinelock", ".", "New", "(", "machinelock", ".", "Config", "{", "AgentName", ":", "agentName", ",", "Clock", ":", "clock", ".", "WallClock", ",", "Logger", ":", "loggo", ".", "GetLogger", "(", "\"", "\"", ")", ",", "LogFilename", ":", "agent", ".", "MachineLockLogFilename", "(", "agentConfig", ")", ",", "}", ")", "\n", "// There will only be an error if the required configuration", "// values are not passed in.", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "a", ".", "machineLock", "=", "machineLock", "\n", "a", ".", "upgradeComplete", "=", "upgradesteps", ".", "NewLock", "(", "agentConfig", ")", "\n\n", "createEngine", ":=", "a", ".", "makeEngineCreator", "(", "agentName", ",", "agentConfig", ".", "UpgradedToVersion", "(", ")", ")", "\n", "charmrepo", ".", "CacheDir", "=", "filepath", ".", "Join", "(", "agentConfig", ".", "DataDir", "(", ")", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "a", ".", "createJujudSymlinks", "(", "agentConfig", ".", "DataDir", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "a", ".", "runner", ".", "StartWorker", "(", "\"", "\"", ",", "createEngine", ")", "\n\n", "// At this point, all workers will have been configured to start", "close", "(", "a", ".", "workersStarted", ")", "\n", "err", "=", "a", ".", "runner", ".", "Wait", "(", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", "{", "case", "jworker", ".", "ErrTerminateAgent", ":", "err", "=", "a", ".", "uninstallAgent", "(", ")", "\n", "case", "jworker", ".", "ErrRebootMachine", ":", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "err", "=", "a", ".", "executeRebootOrShutdown", "(", "params", ".", "ShouldReboot", ")", "\n", "case", "jworker", ".", "ErrShutdownMachine", ":", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "err", "=", "a", ".", "executeRebootOrShutdown", "(", "params", ".", "ShouldShutdown", ")", "\n", "}", "\n", "return", "cmdutil", ".", "AgentDone", "(", "logger", ",", "err", ")", "\n", "}" ]

[ "Run", "runs", "a", "machine", "agent", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "Restart", "(", ")", "error", "{", "// TODO(bootstrap): revisit here to make it only invoked by IAAS.", "name", ":=", "a", ".", "CurrentConfig", "(", ")", ".", "Value", "(", "agent", ".", "AgentServiceName", ")", "\n", "return", "service", ".", "Restart", "(", "name", ")", "\n", "}" ]

[ "Restart", "restarts", "the", "agent", "s", "service", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "setupContainerSupport", "(", "runner", "*", "worker", ".", "Runner", ",", "st", "api", ".", "Connection", ",", "agentConfig", "agent", ".", "Config", ")", "error", "{", "var", "supportedContainers", "[", "]", "instance", ".", "ContainerType", "\n", "supportsContainers", ":=", "container", ".", "ContainersSupported", "(", ")", "\n", "if", "supportsContainers", "{", "supportedContainers", "=", "append", "(", "supportedContainers", ",", "instance", ".", "LXD", ")", "\n", "}", "\n\n", "supportsKvm", ",", "err", ":=", "kvm", ".", "IsKVMSupported", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", "==", "nil", "&&", "supportsKvm", "{", "supportedContainers", "=", "append", "(", "supportedContainers", ",", "instance", ".", "KVM", ")", "\n", "}", "\n\n", "return", "a", ".", "updateSupportedContainers", "(", "runner", ",", "st", ",", "supportedContainers", ",", "agentConfig", ")", "\n", "}" ]

[ "setupContainerSupport", "determines", "what", "containers", "can", "be", "run", "on", "this", "machine", "and", "initialises", "suitable", "infrastructure", "to", "support", "such", "containers", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "updateSupportedContainers", "(", "runner", "*", "worker", ".", "Runner", ",", "st", "api", ".", "Connection", ",", "containers", "[", "]", "instance", ".", "ContainerType", ",", "agentConfig", "agent", ".", "Config", ",", ")", "error", "{", "pr", ":=", "apiprovisioner", ".", "NewState", "(", "st", ")", "\n", "tag", ":=", "agentConfig", ".", "Tag", "(", ")", ".", "(", "names", ".", "MachineTag", ")", "\n", "result", ",", "err", ":=", "pr", ".", "Machines", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "tag", ")", "\n", "}", "\n", "if", "len", "(", "result", ")", "!=", "1", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "result", ")", ")", "\n", "}", "\n", "if", "errors", ".", "IsNotFound", "(", "result", "[", "0", "]", ".", "Err", ")", "||", "(", "result", "[", "0", "]", ".", "Err", "==", "nil", "&&", "result", "[", "0", "]", ".", "Machine", ".", "Life", "(", ")", "==", "params", ".", "Dead", ")", "{", "return", "jworker", ".", "ErrTerminateAgent", "\n", "}", "\n", "machine", ":=", "result", "[", "0", "]", ".", "Machine", "\n", "if", "len", "(", "containers", ")", "==", "0", "{", "if", "err", ":=", "machine", ".", "SupportsNoContainers", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "tag", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "machine", ".", "SetSupportedContainers", "(", "containers", "...", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "tag", ")", "\n", "}", "\n", "// Start the watcher to fire when a container is first requested on the machine.", "watcherName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "machine", ".", "Id", "(", ")", ")", "\n\n", "credentialAPI", ",", "err", ":=", "workercommon", ".", "NewCredentialInvalidatorFacade", "(", "st", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "params", ":=", "provisioner", ".", "ContainerSetupParams", "{", "Runner", ":", "runner", ",", "WorkerName", ":", "watcherName", ",", "SupportedContainers", ":", "containers", ",", "Machine", ":", "machine", ",", "Provisioner", ":", "pr", ",", "Config", ":", "agentConfig", ",", "MachineLock", ":", "a", ".", "machineLock", ",", "CredentialAPI", ":", "credentialAPI", ",", "}", "\n", "handler", ":=", "provisioner", ".", "NewContainerSetupHandler", "(", "params", ")", "\n", "a", ".", "startWorkerAfterUpgrade", "(", "runner", ",", "watcherName", ",", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "w", ",", "err", ":=", "watcher", ".", "NewStringsWorker", "(", "watcher", ".", "StringsConfig", "{", "Handler", ":", "handler", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "watcherName", ")", "\n", "}", "\n", "return", "w", ",", "nil", "\n", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "updateSupportedContainers", "records", "in", "state", "that", "a", "machine", "can", "run", "the", "specified", "containers", ".", "It", "starts", "a", "watcher", "and", "when", "a", "container", "of", "a", "given", "type", "is", "first", "added", "to", "the", "machine", "the", "watcher", "is", "killed", "the", "machine", "is", "set", "up", "to", "be", "able", "to", "start", "containers", "of", "the", "given", "type", "and", "a", "suitable", "provisioner", "is", "started", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "startModelWorkers", "(", "modelUUID", "string", ",", "modelType", "state", ".", "ModelType", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "controllerUUID", ":=", "a", ".", "CurrentConfig", "(", ")", ".", "Controller", "(", ")", ".", "Id", "(", ")", "\n", "modelAgent", ",", "err", ":=", "model", ".", "WrapAgent", "(", "a", ",", "controllerUUID", ",", "modelUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "config", ":=", "dependencyEngineConfig", "(", ")", "\n", "config", ".", "IsFatal", "=", "model", ".", "IsFatal", "\n", "config", ".", "WorstError", "=", "model", ".", "WorstError", "\n", "config", ".", "Filter", "=", "model", ".", "IgnoreErrRemoved", "\n", "engine", ",", "err", ":=", "dependency", ".", "NewEngine", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "manifoldsCfg", ":=", "model", ".", "ManifoldsConfig", "{", "Agent", ":", "modelAgent", ",", "AgentConfigChanged", ":", "a", ".", "configChangedVal", ",", "Clock", ":", "clock", ".", "WallClock", ",", "RunFlagDuration", ":", "time", ".", "Minute", ",", "CharmRevisionUpdateInterval", ":", "24", "*", "time", ".", "Hour", ",", "InstPollerAggregationDelay", ":", "3", "*", "time", ".", "Second", ",", "StatusHistoryPrunerInterval", ":", "5", "*", "time", ".", "Minute", ",", "ActionPrunerInterval", ":", "24", "*", "time", ".", "Hour", ",", "NewEnvironFunc", ":", "newEnvirons", ",", "NewContainerBrokerFunc", ":", "newCAASBroker", ",", "NewMigrationMaster", ":", "migrationmaster", ".", "NewWorker", ",", "}", "\n", "var", "manifolds", "dependency", ".", "Manifolds", "\n", "if", "modelType", "==", "state", ".", "ModelTypeIAAS", "{", "manifolds", "=", "iaasModelManifolds", "(", "manifoldsCfg", ")", "\n", "}", "else", "{", "manifolds", "=", "caasModelManifolds", "(", "manifoldsCfg", ")", "\n", "}", "\n", "if", "err", ":=", "dependency", ".", "Install", "(", "engine", ",", "manifolds", ")", ";", "err", "!=", "nil", "{", "if", "err", ":=", "worker", ".", "Stop", "(", "engine", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "engine", ",", "nil", "\n", "}" ]

[ "startModelWorkers", "starts", "the", "set", "of", "workers", "that", "run", "for", "every", "model", "in", "each", "controller", "both", "IAAS", "and", "CAAS", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "ensureMongoServer", "(", "agentConfig", "agent", ".", "Config", ")", "(", "err", "error", ")", "{", "a", ".", "mongoInitMutex", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "mongoInitMutex", ".", "Unlock", "(", ")", "\n", "if", "a", ".", "mongoInitialized", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "a", ".", "mongoInitialized", "=", "true", "\n", "}", "\n", "}", "(", ")", "\n\n", "if", "a", ".", "isCaasMachineAgent", "{", "return", "nil", "\n", "}", "\n", "// EnsureMongoServer installs/upgrades the init config as necessary.", "ensureServerParams", ",", "err", ":=", "cmdutil", ".", "NewEnsureServerParams", "(", "agentConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "var", "mongodVersion", "mongo", ".", "Version", "\n", "if", "mongodVersion", ",", "err", "=", "cmdutil", ".", "EnsureMongoServer", "(", "ensureServerParams", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "// update Mongo version.", "if", "err", "=", "a", ".", "ChangeConfig", "(", "func", "(", "config", "agent", ".", "ConfigSetter", ")", "error", "{", "config", ".", "SetMongoVersion", "(", "mongodVersion", ")", "\n", "return", "nil", "\n", "}", ",", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ensureMongoServer", "ensures", "that", "mongo", "is", "installed", "and", "running", "and", "ready", "for", "opening", "a", "state", "connection", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "startWorkerAfterUpgrade", "(", "runner", "jworker", ".", "Runner", ",", "name", "string", ",", "start", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", ")", "{", "runner", ".", "StartWorker", "(", "name", ",", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "return", "a", ".", "upgradeWaiterWorker", "(", "name", ",", "start", ")", ",", "nil", "\n", "}", ")", "\n", "}" ]

[ "startWorkerAfterUpgrade", "starts", "a", "worker", "to", "run", "the", "specified", "child", "worker", "but", "only", "after", "waiting", "for", "upgrades", "to", "complete", "." ]

[ "func", "(", "a", "*", "MachineAgent", ")", "upgradeWaiterWorker", "(", "name", "string", ",", "start", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", ")", "worker", ".", "Worker", "{", "return", "jworker", ".", "NewSimpleWorker", "(", "func", "(", "stop", "<-", "chan", "struct", "{", "}", ")", "error", "{", "// Wait for the agent upgrade and upgrade steps to complete (or for us to be stopped).", "for", "_", ",", "ch", ":=", "range", "[", "]", "<-", "chan", "struct", "{", "}", "{", "a", ".", "upgradeComplete", ".", "Unlocked", "(", ")", ",", "a", ".", "initialUpgradeCheckComplete", ".", "Unlocked", "(", ")", ",", "}", "{", "select", "{", "case", "<-", "stop", ":", "return", "nil", "\n", "case", "<-", "ch", ":", "}", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "name", ")", "\n\n", "// Upgrades are done, start the worker.", "w", ",", "err", ":=", "start", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Wait for worker to finish or for us to be stopped.", "done", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "go", "func", "(", ")", "{", "done", "<-", "w", ".", "Wait", "(", ")", "\n", "}", "(", ")", "\n", "select", "{", "case", "err", ":=", "<-", "done", ":", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ")", "\n", "case", "<-", "stop", ":", "logger", ".", "Debugf", "(", "\"", "\"", ",", "name", ")", "\n", "return", "worker", ".", "Stop", "(", "w", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "upgradeWaiterWorker", "runs", "the", "specified", "worker", "after", "upgrades", "have", "completed", "." ]

[ "func", "NewContextRelation", "(", "ru", "*", "uniter", ".", "RelationUnit", ",", "cache", "*", "RelationCache", ")", "*", "ContextRelation", "{", "return", "&", "ContextRelation", "{", "ru", ":", "ru", ",", "relationId", ":", "ru", ".", "Relation", "(", ")", ".", "Id", "(", ")", ",", "endpointName", ":", "ru", ".", "Endpoint", "(", ")", ".", "Name", ",", "cache", ":", "cache", ",", "}", "\n", "}" ]

[ "NewContextRelation", "creates", "a", "new", "context", "for", "the", "given", "relation", "unit", ".", "The", "unit", "-", "name", "keys", "of", "members", "supplies", "the", "initial", "membership", "." ]

[ "func", "(", "ctx", "*", "ContextRelation", ")", "WriteSettings", "(", ")", "(", "err", "error", ")", "{", "if", "ctx", ".", "settings", "!=", "nil", "{", "err", "=", "ctx", ".", "settings", ".", "Write", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "WriteSettings", "persists", "all", "changes", "made", "to", "the", "unit", "s", "relation", "settings", "." ]

[ "func", "(", "ctx", "*", "ContextRelation", ")", "SetStatus", "(", "status", "relation", ".", "Status", ")", "error", "{", "return", "ctx", ".", "ru", ".", "Relation", "(", ")", ".", "SetStatus", "(", "status", ")", "\n", "}" ]

[ "SetStatus", "sets", "the", "relation", "s", "status", "." ]

[ "func", "stateStepsFor22", "(", ")", "[", "]", "Step", "{", "return", "[", "]", "Step", "{", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "AddNonDetachableStorageMachineId", "(", ")", "\n", "}", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "RemoveNilValueApplicationSettings", "(", ")", "\n", "}", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "AddControllerLogCollectionsSizeSettings", "(", ")", "\n", "}", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "AddStatusHistoryPruneSettings", "(", ")", "\n", "}", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "AddStorageInstanceConstraints", "(", ")", "\n", "}", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "SplitLogCollections", "(", ")", "\n", "}", ",", "}", ",", "}", "\n", "}" ]

[ "stateStepsFor22", "returns", "upgrade", "steps", "for", "Juju", "2", ".", "2", "that", "manipulate", "state", "directly", "." ]

[ "func", "stepsFor22", "(", ")", "[", "]", "Step", "{", "return", "[", "]", "Step", "{", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "AllMachines", "}", ",", "run", ":", "removeMeterStatusFile", ",", "}", ",", "}", "\n", "}" ]

[ "stepsFor22", "returns", "upgrade", "steps", "for", "Juju", "2", ".", "2", "that", "only", "need", "the", "API", "." ]

[ "func", "removeMeterStatusFile", "(", "context", "Context", ")", "error", "{", "dataDir", ":=", "context", ".", "AgentConfig", "(", ")", ".", "DataDir", "(", ")", "\n", "meterStatusFile", ":=", "filepath", ".", "Join", "(", "dataDir", ",", "\"", "\"", ")", "\n", "return", "os", ".", "RemoveAll", "(", "meterStatusFile", ")", "\n", "}" ]

[ "removeMeterStatusFile", "removes", "the", "meter", "status", "file", "from", "the", "agent", "data", "directory", "." ]

[ "func", "DiscoverAuthorizationURI", "(", "sdkCtx", "context", ".", "Context", ",", "client", "subscriptions", ".", "Client", ",", "subscriptionID", "string", ")", "(", "*", "url", ".", "URL", ",", "error", ")", "{", "// We make an unauthenticated request to the Azure API, which", "// responds with the authentication URL with the tenant ID in it.", "result", ",", "err", ":=", "client", ".", "Get", "(", "sdkCtx", ",", "subscriptionID", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "result", ".", "Response", ".", "Response", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "result", ".", "StatusCode", "!=", "http", ".", "StatusUnauthorized", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "result", ".", "StatusCode", ")", "\n", "}", "\n\n", "header", ":=", "result", ".", "Header", ".", "Get", "(", "authenticateHeaderKey", ")", "\n", "if", "header", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "authenticateHeaderKey", ")", "\n", "}", "\n", "match", ":=", "authorizationUriRegexp", ".", "FindStringSubmatch", "(", "header", ")", "\n", "if", "match", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "authenticateHeaderKey", ",", "header", ",", ")", "\n", "}", "\n", "return", "url", ".", "Parse", "(", "match", "[", "1", "]", ")", "\n", "}" ]

[ "DiscoverAuthorizationID", "returns", "the", "OAuth", "authorization", "URI", "for", "the", "given", "subscription", "ID", ".", "This", "can", "be", "used", "to", "determine", "the", "AD", "tenant", "ID", "." ]

[ "func", "AuthorizationURITenantID", "(", "url", "*", "url", ".", "URL", ")", "(", "string", ",", "error", ")", "{", "path", ":=", "strings", ".", "TrimPrefix", "(", "url", ".", "Path", ",", "\"", "\"", ")", "\n", "if", "_", ",", "err", ":=", "utils", ".", "UUIDFromString", "(", "path", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "url", ")", "\n", "}", "\n", "return", "path", ",", "nil", "\n", "}" ]

[ "AuthorizationURITenantID", "returns", "the", "tenant", "ID", "portion", "of", "the", "given", "URL", "which", "is", "expected", "to", "have", "come", "from", "DiscoverAuthorizationURI", "." ]

[ "func", "NewUpgrader", "(", "toSeries", "string", ",", "manager", "service", ".", "SystemdServiceManager", ",", "logger", "Logger", ")", "(", "Upgrader", ",", "error", ")", "{", "fromSeries", ",", "err", ":=", "hostSeries", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "fromInit", ",", "err", ":=", "service", ".", "VersionInitSystem", "(", "fromSeries", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "toInit", ",", "err", ":=", "service", ".", "VersionInitSystem", "(", "toSeries", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "upgrader", "{", "logger", ":", "logger", ",", "fromSeries", ":", "fromSeries", ",", "fromInit", ":", "fromInit", ",", "toSeries", ":", "toSeries", ",", "toInit", ":", "toInit", ",", "manager", ":", "manager", ",", "}", ",", "nil", "\n", "}" ]

[ "NewUpgrader", "uses", "the", "input", "function", "to", "determine", "the", "series", "that", "should", "be", "supported", "and", "returns", "a", "reference", "to", "a", "new", "Upgrader", "that", "supports", "it", "." ]

[ "func", "(", "u", "*", "upgrader", ")", "PerformUpgrade", "(", ")", "error", "{", "if", "err", ":=", "u", ".", "populateAgents", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "u", ".", "ensureSystemdFiles", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "errors", ".", "Trace", "(", "u", ".", "ensureAgentBinaries", "(", ")", ")", "\n", "}" ]

[ "PerformUpgrade", "writes", "Juju", "binaries", "and", "service", "files", "that", "allow", "the", "machine", "and", "unit", "agents", "to", "run", "on", "the", "target", "version", "of", "Ubuntu", "." ]

[ "func", "(", "u", "*", "upgrader", ")", "populateAgents", "(", ")", "(", "err", "error", ")", "{", "var", "unknown", "[", "]", "string", "\n", "u", ".", "machineAgent", ",", "u", ".", "unitAgents", ",", "unknown", ",", "err", "=", "u", ".", "manager", ".", "FindAgents", "(", "paths", ".", "NixDataDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "unknown", ")", ">", "0", "{", "u", ".", "logger", ".", "Warningf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "unknown", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "populateAgents", "discovers", "and", "sets", "the", "names", "of", "the", "machine", "and", "unit", "agents", ".", "If", "there", "are", "any", "other", "agents", "determined", "a", "warning", "is", "logged", "to", "notify", "that", "they", "are", "being", "skipped", "from", "the", "upgrade", "process", "." ]

[ "func", "(", "u", "*", "upgrader", ")", "ensureSystemdFiles", "(", ")", "error", "{", "if", "u", ".", "fromInit", "==", "service", ".", "InitSystemSystemd", "||", "u", ".", "toInit", "!=", "service", ".", "InitSystemSystemd", "{", "return", "nil", "\n", "}", "\n\n", "services", ",", "links", ",", "failed", ",", "err", ":=", "u", ".", "manager", ".", "WriteSystemdAgents", "(", "u", ".", "machineAgent", ",", "u", ".", "unitAgents", ",", "paths", ".", "NixDataDir", ",", "systemdDir", ",", "systemdMultiUserDir", ")", "\n\n", "if", "len", "(", "services", ")", ">", "0", "{", "u", ".", "logger", ".", "Infof", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "services", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "len", "(", "links", ")", ">", "0", "{", "u", ".", "logger", ".", "Infof", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "links", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "strings", ".", "Join", "(", "failed", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "ensureSystemdFiles", "determines", "whether", "re", "-", "writing", "service", "files", "to", "target", "systemd", "is", "required", ".", "If", "it", "is", "the", "necessary", "changes", "are", "invoked", "via", "the", "service", "manager", "." ]

[ "func", "(", "u", "*", "upgrader", ")", "ensureAgentBinaries", "(", ")", "error", "{", "if", "err", ":=", "u", ".", "manager", ".", "CopyAgentBinary", "(", "u", ".", "machineAgent", ",", "u", ".", "unitAgents", ",", "paths", ".", "NixDataDir", ",", "u", ".", "toSeries", ",", "u", ".", "fromSeries", ",", "version", ".", "Current", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "u", ".", "logger", ".", "Infof", "(", "\"", "\"", ",", "u", ".", "toSeries", ")", "\n", "return", "nil", "\n", "}" ]

[ "ensureAgentBinaries", "ensures", "that", "the", "jujud", "binary", "and", "links", "exist", "in", "the", "right", "tools", "path", "for", "the", "target", "OS", "series", "and", "that", "individual", "agents", "use", "those", "files", "." ]

[ "func", "(", "c", "*", "Client", ")", "unitStatusHistory", "(", "unitTag", "names", ".", "UnitTag", ",", "filter", "status", ".", "StatusHistoryFilter", ",", "kind", "status", ".", "HistoryKind", ")", "(", "[", "]", "params", ".", "DetailedStatus", ",", "error", ")", "{", "unit", ",", "err", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Unit", "(", "unitTag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "statuses", ":=", "[", "]", "params", ".", "DetailedStatus", "{", "}", "\n", "if", "kind", "==", "status", ".", "KindUnit", "||", "kind", "==", "status", ".", "KindWorkload", "{", "unitStatuses", ",", "err", ":=", "unit", ".", "StatusHistory", "(", "filter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "statuses", "=", "agentStatusFromStatusInfo", "(", "unitStatuses", ",", "status", ".", "KindWorkload", ")", "\n\n", "}", "\n", "if", "kind", "==", "status", ".", "KindUnit", "||", "kind", "==", "status", ".", "KindUnitAgent", "{", "agentStatuses", ",", "err", ":=", "unit", ".", "AgentHistory", "(", ")", ".", "StatusHistory", "(", "filter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "statuses", "=", "append", "(", "statuses", ",", "agentStatusFromStatusInfo", "(", "agentStatuses", ",", "status", ".", "KindUnitAgent", ")", "...", ")", "\n", "}", "\n\n", "sort", ".", "Sort", "(", "byTime", "(", "statuses", ")", ")", "\n", "if", "kind", "==", "status", ".", "KindUnit", "&&", "filter", ".", "Size", ">", "0", "{", "if", "len", "(", "statuses", ")", ">", "filter", ".", "Size", "{", "statuses", "=", "statuses", "[", "len", "(", "statuses", ")", "-", "filter", ".", "Size", ":", "]", "\n", "}", "\n", "}", "\n\n", "return", "statuses", ",", "nil", "\n", "}" ]

[ "unitStatusHistory", "returns", "a", "list", "of", "status", "history", "entries", "for", "unit", "agents", "or", "workloads", "." ]

[ "func", "(", "c", "*", "Client", ")", "machineStatusHistory", "(", "machineTag", "names", ".", "MachineTag", ",", "filter", "status", ".", "StatusHistoryFilter", ",", "kind", "status", ".", "HistoryKind", ")", "(", "[", "]", "params", ".", "DetailedStatus", ",", "error", ")", "{", "machine", ",", "err", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Machine", "(", "machineTag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "sInfo", "[", "]", "status", ".", "StatusInfo", "\n", "if", "kind", "==", "status", ".", "KindMachineInstance", "||", "kind", "==", "status", ".", "KindContainerInstance", "{", "sInfo", ",", "err", "=", "machine", ".", "InstanceStatusHistory", "(", "filter", ")", "\n", "}", "else", "{", "sInfo", ",", "err", "=", "machine", ".", "StatusHistory", "(", "filter", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "agentStatusFromStatusInfo", "(", "sInfo", ",", "kind", ")", ",", "nil", "\n", "}" ]

[ "machineStatusHistory", "returns", "status", "history", "for", "the", "given", "machine", "." ]

[ "func", "(", "c", "*", "Client", ")", "StatusHistory", "(", "request", "params", ".", "StatusHistoryRequests", ")", "params", ".", "StatusHistoryResults", "{", "results", ":=", "params", ".", "StatusHistoryResults", "{", "}", "\n", "// TODO(perrito666) the contents of the loop could be split into", "// a oneHistory method for clarity.", "for", "_", ",", "request", ":=", "range", "request", ".", "Requests", "{", "filter", ":=", "status", ".", "StatusHistoryFilter", "{", "Size", ":", "request", ".", "Filter", ".", "Size", ",", "FromDate", ":", "request", ".", "Filter", ".", "Date", ",", "Delta", ":", "request", ".", "Filter", ".", "Delta", ",", "Exclude", ":", "set", ".", "NewStrings", "(", "request", ".", "Filter", ".", "Exclude", "...", ")", ",", "}", "\n", "if", "err", ":=", "c", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "history", ":=", "params", ".", "StatusHistoryResult", "{", "Error", ":", "common", ".", "ServerError", "(", "err", ")", ",", "}", "\n", "results", ".", "Results", "=", "append", "(", "results", ".", "Results", ",", "history", ")", "\n", "continue", "\n\n", "}", "\n\n", "if", "err", ":=", "filter", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "history", ":=", "params", ".", "StatusHistoryResult", "{", "Error", ":", "common", ".", "ServerError", "(", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ")", ",", "}", "\n", "results", ".", "Results", "=", "append", "(", "results", ".", "Results", ",", "history", ")", "\n", "continue", "\n", "}", "\n\n", "var", "(", "err", "error", "\n", "hist", "[", "]", "params", ".", "DetailedStatus", "\n", ")", "\n", "kind", ":=", "status", ".", "HistoryKind", "(", "request", ".", "Kind", ")", "\n", "err", "=", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "kind", ",", "request", ".", "Tag", ")", "\n", "switch", "kind", "{", "case", "status", ".", "KindUnit", ",", "status", ".", "KindWorkload", ",", "status", ".", "KindUnitAgent", ":", "var", "u", "names", ".", "UnitTag", "\n", "if", "u", ",", "err", "=", "names", ".", "ParseUnitTag", "(", "request", ".", "Tag", ")", ";", "err", "==", "nil", "{", "hist", ",", "err", "=", "c", ".", "unitStatusHistory", "(", "u", ",", "filter", ",", "kind", ")", "\n", "}", "\n", "default", ":", "var", "m", "names", ".", "MachineTag", "\n", "if", "m", ",", "err", "=", "names", ".", "ParseMachineTag", "(", "request", ".", "Tag", ")", ";", "err", "==", "nil", "{", "hist", ",", "err", "=", "c", ".", "machineStatusHistory", "(", "m", ",", "filter", ",", "kind", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", "==", "nil", "{", "sort", ".", "Sort", "(", "byTime", "(", "hist", ")", ")", "\n", "}", "\n\n", "results", ".", "Results", "=", "append", "(", "results", ".", "Results", ",", "params", ".", "StatusHistoryResult", "{", "History", ":", "params", ".", "History", "{", "Statuses", ":", "hist", "}", ",", "Error", ":", "common", ".", "ServerError", "(", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "request", ".", "Tag", ")", ")", ",", "}", ")", "\n", "}", "\n", "return", "results", "\n", "}" ]

[ "StatusHistory", "returns", "a", "slice", "of", "past", "statuses", "for", "several", "entities", "." ]

[ "func", "(", "c", "*", "Client", ")", "modelStatus", "(", ")", "(", "params", ".", "ModelStatusInfo", ",", "error", ")", "{", "var", "info", "params", ".", "ModelStatusInfo", "\n\n", "m", ",", "err", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "info", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "info", ".", "Name", "=", "m", ".", "Name", "(", ")", "\n", "info", ".", "Type", "=", "string", "(", "m", ".", "Type", "(", ")", ")", "\n", "info", ".", "CloudTag", "=", "names", ".", "NewCloudTag", "(", "m", ".", "Cloud", "(", ")", ")", ".", "String", "(", ")", "\n", "info", ".", "CloudRegion", "=", "m", ".", "CloudRegion", "(", ")", "\n\n", "cfg", ",", "err", ":=", "m", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ModelStatusInfo", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "latestVersion", ":=", "m", ".", "LatestToolsVersion", "(", ")", "\n", "current", ",", "ok", ":=", "cfg", ".", "AgentVersion", "(", ")", "\n", "if", "ok", "{", "info", ".", "Version", "=", "current", ".", "String", "(", ")", "\n", "if", "current", ".", "Compare", "(", "latestVersion", ")", "<", "0", "{", "info", ".", "AvailableVersion", "=", "latestVersion", ".", "String", "(", ")", "\n", "}", "\n", "}", "\n\n", "status", ",", "err", ":=", "m", ".", "Status", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ModelStatusInfo", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "info", ".", "SLA", "=", "m", ".", "SLALevel", "(", ")", "\n\n", "info", ".", "ModelStatus", "=", "params", ".", "DetailedStatus", "{", "Status", ":", "status", ".", "Status", ".", "String", "(", ")", ",", "Info", ":", "status", ".", "Message", ",", "Since", ":", "status", ".", "Since", ",", "Data", ":", "status", ".", "Data", ",", "}", "\n\n", "if", "info", ".", "SLA", "!=", "\"", "\"", "{", "ms", ":=", "m", ".", "MeterStatus", "(", ")", "\n", "if", "isColorStatus", "(", "ms", ".", "Code", ")", "{", "info", ".", "MeterStatus", "=", "params", ".", "MeterStatus", "{", "Color", ":", "strings", ".", "ToLower", "(", "ms", ".", "Code", ".", "String", "(", ")", ")", ",", "Message", ":", "ms", ".", "Info", "}", "\n", "}", "\n", "}", "\n\n", "return", "info", ",", "nil", "\n", "}" ]

[ "newToolsVersionAvailable", "will", "return", "a", "string", "representing", "a", "tools", "version", "only", "if", "the", "latest", "check", "is", "newer", "than", "current", "tools", "." ]

[ "func", "fetchNetworkInterfaces", "(", "st", "Backend", ")", "(", "map", "[", "string", "]", "[", "]", "*", "state", ".", "Address", ",", "map", "[", "string", "]", "map", "[", "string", "]", "set", ".", "Strings", ",", "map", "[", "string", "]", "[", "]", "*", "state", ".", "LinkLayerDevice", ",", "error", ")", "{", "ipAddresses", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "*", "state", ".", "Address", ")", "\n", "spaces", ":=", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "set", ".", "Strings", ")", "\n", "subnets", ",", "err", ":=", "st", ".", "AllSubnets", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "subnetsByCIDR", ":=", "make", "(", "map", "[", "string", "]", "*", "state", ".", "Subnet", ")", "\n", "for", "_", ",", "subnet", ":=", "range", "subnets", "{", "subnetsByCIDR", "[", "subnet", ".", "CIDR", "(", ")", "]", "=", "subnet", "\n", "}", "\n", "// For every machine, track what devices have addresses so we can filter linklayerdevices later", "devicesWithAddresses", ":=", "make", "(", "map", "[", "string", "]", "set", ".", "Strings", ")", "\n", "ipAddrs", ",", "err", ":=", "st", ".", "AllIPAddresses", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "ipAddr", ":=", "range", "ipAddrs", "{", "if", "ipAddr", ".", "LoopbackConfigMethod", "(", ")", "{", "continue", "\n", "}", "\n", "machineID", ":=", "ipAddr", ".", "MachineID", "(", ")", "\n", "ipAddresses", "[", "machineID", "]", "=", "append", "(", "ipAddresses", "[", "machineID", "]", ",", "ipAddr", ")", "\n", "if", "subnet", ",", "ok", ":=", "subnetsByCIDR", "[", "ipAddr", ".", "SubnetCIDR", "(", ")", "]", ";", "ok", "{", "if", "spaceName", ":=", "subnet", ".", "SpaceName", "(", ")", ";", "spaceName", "!=", "\"", "\"", "{", "devices", ",", "ok", ":=", "spaces", "[", "machineID", "]", "\n", "if", "!", "ok", "{", "devices", "=", "make", "(", "map", "[", "string", "]", "set", ".", "Strings", ")", "\n", "spaces", "[", "machineID", "]", "=", "devices", "\n", "}", "\n", "deviceName", ":=", "ipAddr", ".", "DeviceName", "(", ")", "\n", "spacesSet", ",", "ok", ":=", "devices", "[", "deviceName", "]", "\n", "if", "!", "ok", "{", "spacesSet", "=", "make", "(", "set", ".", "Strings", ")", "\n", "devices", "[", "deviceName", "]", "=", "spacesSet", "\n", "}", "\n", "spacesSet", ".", "Add", "(", "spaceName", ")", "\n", "}", "\n", "}", "\n", "deviceSet", ",", "ok", ":=", "devicesWithAddresses", "[", "machineID", "]", "\n", "if", "ok", "{", "deviceSet", ".", "Add", "(", "ipAddr", ".", "DeviceName", "(", ")", ")", "\n", "}", "else", "{", "devicesWithAddresses", "[", "machineID", "]", "=", "set", ".", "NewStrings", "(", "ipAddr", ".", "DeviceName", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "linkLayerDevices", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "*", "state", ".", "LinkLayerDevice", ")", "\n", "llDevs", ",", "err", ":=", "st", ".", "AllLinkLayerDevices", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "llDev", ":=", "range", "llDevs", "{", "if", "llDev", ".", "IsLoopbackDevice", "(", ")", "{", "continue", "\n", "}", "\n", "machineID", ":=", "llDev", ".", "MachineID", "(", ")", "\n", "machineDevs", ",", "ok", ":=", "devicesWithAddresses", "[", "machineID", "]", "\n", "if", "!", "ok", "{", "// This machine ID doesn't seem to have any devices with IP Addresses", "continue", "\n", "}", "\n", "if", "!", "machineDevs", ".", "Contains", "(", "llDev", ".", "Name", "(", ")", ")", "{", "// this device did not have any IP Addresses", "continue", "\n", "}", "\n", "// This device had an IP Address, so include it in the list of devices for this machine", "linkLayerDevices", "[", "machineID", "]", "=", "append", "(", "linkLayerDevices", "[", "machineID", "]", ",", "llDev", ")", "\n", "}", "\n\n", "return", "ipAddresses", ",", "spaces", ",", "linkLayerDevices", ",", "nil", "\n", "}" ]

[ "fetchNetworkInterfaces", "returns", "maps", "from", "machine", "id", "to", "ip", ".", "addresses", "machine", "id", "to", "a", "map", "of", "interface", "names", "from", "space", "names", "and", "machine", "id", "to", "linklayerdevices", ".", "All", "are", "required", "to", "determine", "a", "machine", "s", "network", "interfaces", "configuration", "so", "we", "want", "all", "or", "none", "." ]

[ "func", "fetchAllApplicationsAndUnits", "(", "st", "Backend", ",", "model", "*", "state", ".", "Model", ",", ")", "(", "applicationStatusInfo", ",", "error", ")", "{", "appMap", ":=", "make", "(", "map", "[", "string", "]", "*", "state", ".", "Application", ")", "\n", "unitMap", ":=", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "*", "state", ".", "Unit", ")", "\n", "latestCharms", ":=", "make", "(", "map", "[", "charm", ".", "URL", "]", "*", "state", ".", "Charm", ")", "\n", "applications", ",", "err", ":=", "st", ".", "AllApplications", "(", ")", "\n", "units", ",", "err", ":=", "model", ".", "AllUnits", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "applicationStatusInfo", "{", "}", ",", "err", "\n", "}", "\n", "allUnitsByApp", ":=", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "*", "state", ".", "Unit", ")", "\n", "for", "_", ",", "unit", ":=", "range", "units", "{", "appName", ":=", "unit", ".", "ApplicationName", "(", ")", "\n\n", "if", "inner", ",", "found", ":=", "allUnitsByApp", "[", "appName", "]", ";", "found", "{", "inner", "[", "unit", ".", "Name", "(", ")", "]", "=", "unit", "\n", "}", "else", "{", "allUnitsByApp", "[", "appName", "]", "=", "map", "[", "string", "]", "*", "state", ".", "Unit", "{", "unit", ".", "Name", "(", ")", ":", "unit", ",", "}", "\n", "}", "\n", "}", "\n\n", "endpointBindings", ",", "err", ":=", "model", ".", "AllEndpointBindings", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "applicationStatusInfo", "{", "}", ",", "err", "\n", "}", "\n", "allBindingsByApp", ":=", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "bindings", ":=", "range", "endpointBindings", "{", "allBindingsByApp", "[", "bindings", ".", "AppName", "]", "=", "bindings", ".", "Bindings", "\n", "}", "\n\n", "lxdProfiles", ":=", "make", "(", "map", "[", "string", "]", "*", "charm", ".", "LXDProfile", ")", "\n", "for", "_", ",", "app", ":=", "range", "applications", "{", "appMap", "[", "app", ".", "Name", "(", ")", "]", "=", "app", "\n", "appUnits", ":=", "allUnitsByApp", "[", "app", ".", "Name", "(", ")", "]", "\n", "charmURL", ",", "_", ":=", "app", ".", "CharmURL", "(", ")", "\n\n", "if", "len", "(", "appUnits", ")", ">", "0", "{", "unitMap", "[", "app", ".", "Name", "(", ")", "]", "=", "appUnits", "\n", "// Record the base URL for the application's charm so that", "// the latest store revision can be looked up.", "if", "charmURL", ".", "Schema", "==", "\"", "\"", "{", "latestCharms", "[", "*", "charmURL", ".", "WithRevision", "(", "-", "1", ")", "]", "=", "nil", "\n", "}", "\n", "}", "\n\n", "ch", ",", "_", ",", "err", ":=", "app", ".", "Charm", "(", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "chName", ":=", "lxdprofile", ".", "Name", "(", "model", ".", "Name", "(", ")", ",", "app", ".", "Name", "(", ")", ",", "ch", ".", "Revision", "(", ")", ")", "\n", "if", "profile", ":=", "ch", ".", "LXDProfile", "(", ")", ";", "profile", "!=", "nil", "{", "lxdProfiles", "[", "chName", "]", "=", "profile", "\n", "}", "\n", "}", "\n\n", "for", "baseURL", ":=", "range", "latestCharms", "{", "ch", ",", "err", ":=", "st", ".", "LatestPlaceholderCharm", "(", "&", "baseURL", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "applicationStatusInfo", "{", "}", ",", "err", "\n", "}", "\n", "latestCharms", "[", "baseURL", "]", "=", "ch", "\n", "}", "\n\n", "return", "applicationStatusInfo", "{", "applications", ":", "appMap", ",", "units", ":", "unitMap", ",", "latestCharms", ":", "latestCharms", ",", "endpointBindings", ":", "allBindingsByApp", ",", "lxdProfiles", ":", "lxdProfiles", ",", "}", ",", "nil", "\n", "}" ]

[ "fetchAllApplicationsAndUnits", "returns", "a", "map", "from", "application", "name", "to", "application", "a", "map", "from", "application", "name", "to", "unit", "name", "to", "unit", "and", "a", "map", "from", "base", "charm", "URL", "to", "latest", "URL", "." ]

[ "func", "fetchConsumerRemoteApplications", "(", "st", "Backend", ")", "(", "map", "[", "string", "]", "*", "state", ".", "RemoteApplication", ",", "error", ")", "{", "appMap", ":=", "make", "(", "map", "[", "string", "]", "*", "state", ".", "RemoteApplication", ")", "\n", "applications", ",", "err", ":=", "st", ".", "AllRemoteApplications", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "a", ":=", "range", "applications", "{", "if", "_", ",", "ok", ":=", "a", ".", "URL", "(", ")", ";", "!", "ok", "{", "continue", "\n", "}", "\n", "appMap", "[", "a", ".", "Name", "(", ")", "]", "=", "a", "\n", "}", "\n", "return", "appMap", ",", "nil", "\n", "}" ]

[ "fetchConsumerRemoteApplications", "returns", "a", "map", "from", "application", "name", "to", "remote", "application", "." ]

[ "func", "fetchOffers", "(", "st", "Backend", ",", "applications", "map", "[", "string", "]", "*", "state", ".", "Application", ")", "(", "map", "[", "string", "]", "offerStatus", ",", "error", ")", "{", "offersMap", ":=", "make", "(", "map", "[", "string", "]", "offerStatus", ")", "\n", "offers", ",", "err", ":=", "st", ".", "AllApplicationOffers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "offer", ":=", "range", "offers", "{", "offerInfo", ":=", "offerStatus", "{", "ApplicationOffer", ":", "crossmodel", ".", "ApplicationOffer", "{", "OfferName", ":", "offer", ".", "OfferName", ",", "OfferUUID", ":", "offer", ".", "OfferUUID", ",", "ApplicationName", ":", "offer", ".", "ApplicationName", ",", "Endpoints", ":", "offer", ".", "Endpoints", ",", "}", ",", "}", "\n", "app", ",", "ok", ":=", "applications", "[", "offer", ".", "ApplicationName", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "curl", ",", "_", ":=", "app", ".", "CharmURL", "(", ")", "\n", "offerInfo", ".", "charmURL", "=", "curl", ".", "String", "(", ")", "\n", "rc", ",", "err", ":=", "st", ".", "RemoteConnectionStatus", "(", "offer", ".", "OfferUUID", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "offerInfo", ".", "err", "=", "err", "\n", "continue", "\n", "}", "else", "if", "err", "==", "nil", "{", "offerInfo", ".", "totalConnectedCount", "=", "rc", ".", "TotalConnectionCount", "(", ")", "\n", "offerInfo", ".", "activeConnectedCount", "=", "rc", ".", "ActiveConnectionCount", "(", ")", "\n", "}", "\n", "offersMap", "[", "offer", ".", "OfferName", "]", "=", "offerInfo", "\n", "}", "\n", "return", "offersMap", ",", "nil", "\n", "}" ]

[ "fetchOfferConnections", "returns", "a", "map", "from", "relation", "id", "to", "offer", "connection", "." ]

[ "func", "(", "context", "*", "statusContext", ")", "getAllRelations", "(", ")", "[", "]", "*", "state", ".", "Relation", "{", "var", "out", "[", "]", "*", "state", ".", "Relation", "\n", "seenRelations", ":=", "make", "(", "map", "[", "int", "]", "bool", ")", "\n", "for", "_", ",", "relations", ":=", "range", "context", ".", "relations", "{", "for", "_", ",", "relation", ":=", "range", "relations", "{", "if", "_", ",", "found", ":=", "seenRelations", "[", "relation", ".", "Id", "(", ")", "]", ";", "!", "found", "{", "out", "=", "append", "(", "out", ",", "relation", ")", "\n", "seenRelations", "[", "relation", ".", "Id", "(", ")", "]", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "This", "method", "exists", "only", "to", "dedup", "the", "loaded", "relations", "as", "they", "will", "appear", "multiple", "times", "in", "context", ".", "relations", "." ]

[ "func", "paramsJobsFromJobs", "(", "jobs", "[", "]", "state", ".", "MachineJob", ")", "[", "]", "multiwatcher", ".", "MachineJob", "{", "paramsJobs", ":=", "make", "(", "[", "]", "multiwatcher", ".", "MachineJob", ",", "len", "(", "jobs", ")", ")", "\n", "for", "i", ",", "machineJob", ":=", "range", "jobs", "{", "paramsJobs", "[", "i", "]", "=", "machineJob", ".", "ToParams", "(", ")", "\n", "}", "\n", "return", "paramsJobs", "\n", "}" ]

[ "paramsJobsFromJobs", "converts", "state", "jobs", "to", "params", "jobs", "." ]

[ "func", "(", "c", "*", "contextUnit", ")", "AgentStatus", "(", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "c", ".", "context", ".", "status", ".", "UnitAgent", "(", "c", ".", "Name", "(", ")", ")", "\n", "}" ]

[ "AgentStatus", "implements", "UnitStatusGetter", "." ]

[ "func", "(", "c", "*", "contextUnit", ")", "Status", "(", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "c", ".", "context", ".", "status", ".", "UnitWorkload", "(", "c", ".", "Name", "(", ")", ",", "c", ".", "expectWorkload", ")", "\n", "}" ]

[ "Status", "implements", "UnitStatusGetter", "." ]

[ "func", "(", "c", "*", "statusContext", ")", "processUnitAndAgentStatus", "(", "unit", "*", "state", ".", "Unit", ",", "expectWorkload", "bool", ")", "(", "agentStatus", ",", "workloadStatus", "params", ".", "DetailedStatus", ")", "{", "wrapped", ":=", "&", "contextUnit", "{", "unit", ",", "expectWorkload", ",", "c", "}", "\n", "agent", ",", "workload", ":=", "c", ".", "presence", ".", "UnitStatus", "(", "wrapped", ")", "\n", "populateStatusFromStatusInfoAndErr", "(", "&", "agentStatus", ",", "agent", ".", "Status", ",", "agent", ".", "Err", ")", "\n", "populateStatusFromStatusInfoAndErr", "(", "&", "workloadStatus", ",", "workload", ".", "Status", ",", "workload", ".", "Err", ")", "\n\n", "agentStatus", ".", "Life", "=", "processLife", "(", "unit", ")", "\n\n", "if", "t", ",", "err", ":=", "unit", ".", "AgentTools", "(", ")", ";", "err", "==", "nil", "{", "agentStatus", ".", "Version", "=", "t", ".", "Version", ".", "Number", ".", "String", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "processUnitAndAgentStatus", "retrieves", "status", "information", "for", "both", "unit", "and", "unitAgents", "." ]

[ "func", "(", "c", "*", "contextMachine", ")", "Status", "(", ")", "(", "status", ".", "StatusInfo", ",", "error", ")", "{", "return", "c", ".", "context", ".", "status", ".", "MachineAgent", "(", "c", ".", "Id", "(", ")", ")", "\n", "}" ]

[ "Return", "the", "agent", "status", "for", "the", "machine", "." ]

[ "func", "(", "c", "*", "statusContext", ")", "processMachine", "(", "machine", "*", "state", ".", "Machine", ")", "(", "out", "params", ".", "DetailedStatus", ")", "{", "wrapped", ":=", "&", "contextMachine", "{", "machine", ",", "c", "}", "\n", "statusInfo", ",", "err", ":=", "c", ".", "presence", ".", "MachineStatus", "(", "wrapped", ")", "\n", "populateStatusFromStatusInfoAndErr", "(", "&", "out", ",", "statusInfo", ",", "err", ")", "\n\n", "out", ".", "Life", "=", "processLife", "(", "machine", ")", "\n\n", "if", "t", ",", "err", ":=", "machine", ".", "AgentTools", "(", ")", ";", "err", "==", "nil", "{", "out", ".", "Version", "=", "t", ".", "Version", ".", "Number", ".", "String", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "processMachine", "retrieves", "version", "and", "status", "information", "for", "the", "given", "machine", ".", "It", "also", "returns", "deprecated", "legacy", "status", "information", "." ]

[ "func", "filterStatusData", "(", "status", "map", "[", "string", "]", "interface", "{", "}", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "out", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "name", ",", "value", ":=", "range", "status", "{", "// use a set here if we end up with a larger whitelist", "if", "name", "==", "\"", "\"", "{", "out", "[", "name", "]", "=", "value", "\n", "}", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "filterStatusData", "limits", "what", "agent", "StatusData", "data", "is", "passed", "over", "the", "API", ".", "This", "prevents", "unintended", "leakage", "of", "internal", "-", "only", "data", "." ]

[ "func", "(", "ctxt", "*", "httpContext", ")", "stateForRequestUnauthenticated", "(", "r", "*", "http", ".", "Request", ")", "(", "*", "state", ".", "PooledState", ",", "error", ")", "{", "modelUUID", ":=", "httpcontext", ".", "RequestModelUUID", "(", "r", ")", "\n", "st", ",", "err", ":=", "ctxt", ".", "srv", ".", "shared", ".", "statePool", ".", "Get", "(", "modelUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "st", ",", "nil", "\n", "}" ]

[ "stateForRequestUnauthenticated", "returns", "a", "state", "instance", "appropriate", "for", "using", "for", "the", "model", "implicit", "in", "the", "given", "request", "without", "checking", "any", "authentication", "information", "." ]

[ "func", "(", "ctxt", "*", "httpContext", ")", "stateForRequestAuthenticated", "(", "r", "*", "http", ".", "Request", ")", "(", "resultSt", "*", "state", ".", "PooledState", ",", "resultEntity", "state", ".", "Entity", ",", "err", "error", ",", ")", "{", "authInfo", ",", "ok", ":=", "httpcontext", ".", "RequestAuthInfo", "(", "r", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "st", ",", "err", ":=", "ctxt", ".", "stateForRequestUnauthenticated", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "// Here err is the named return arg.", "if", "err", "!=", "nil", "{", "st", ".", "Release", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "st", ",", "authInfo", ".", "Entity", ",", "nil", "\n", "}" ]

[ "stateForRequestAuthenticated", "returns", "a", "state", "instance", "appropriate", "for", "using", "for", "the", "model", "implicit", "in", "the", "given", "request", ".", "It", "also", "returns", "the", "authenticated", "entity", "." ]

[ "func", "checkPermissions", "(", "tag", "names", ".", "Tag", ",", "acceptFunc", "common", ".", "GetAuthFunc", ")", "(", "bool", ",", "error", ")", "{", "accept", ",", "err", ":=", "acceptFunc", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "accept", "(", "tag", ")", "{", "return", "true", ",", "nil", "\n", "}", "\n", "return", "false", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "tag", ".", "Kind", "(", ")", ")", "\n", "}" ]

[ "checkPermissions", "verifies", "that", "given", "tag", "passes", "authentication", "check", ".", "For", "example", "if", "only", "user", "tags", "are", "accepted", "all", "other", "tags", "will", "be", "denied", "access", "." ]

[ "func", "(", "ctxt", "*", "httpContext", ")", "stateForMigration", "(", "r", "*", "http", ".", "Request", ",", "requiredMode", "state", ".", "MigrationMode", ",", ")", "(", "_", "*", "state", ".", "PooledState", ",", "err", "error", ")", "{", "modelUUID", ":=", "r", ".", "Header", ".", "Get", "(", "params", ".", "MigrationModelHTTPHeader", ")", "\n", "migrationSt", ",", "err", ":=", "ctxt", ".", "srv", ".", "shared", ".", "statePool", ".", "Get", "(", "modelUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "// Here err is the named return arg.", "if", "err", "!=", "nil", "{", "migrationSt", ".", "Release", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n", "model", ",", "err", ":=", "migrationSt", ".", "Model", "(", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "common", ".", "UnknownModelError", "(", "modelUUID", ")", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "model", ".", "MigrationMode", "(", ")", "!=", "requiredMode", "{", "return", "nil", ",", "errors", ".", "BadRequestf", "(", "\"", "\"", ",", "model", ".", "MigrationMode", "(", ")", ",", "requiredMode", ")", "\n", "}", "\n", "return", "migrationSt", ",", "nil", "\n", "}" ]

[ "stateForMigration", "asserts", "that", "the", "incoming", "connection", "is", "from", "a", "user", "that", "has", "admin", "permissions", "on", "the", "controller", "model", ".", "The", "method", "also", "gets", "the", "model", "uuid", "for", "the", "model", "being", "migrated", "from", "a", "request", "header", "and", "returns", "the", "state", "instance", "for", "that", "model", "." ]

[ "func", "(", "ctxt", "*", "httpContext", ")", "stateForRequestAuthenticatedUser", "(", "r", "*", "http", ".", "Request", ")", "(", "*", "state", ".", "PooledState", ",", "error", ")", "{", "st", ",", "_", ",", "err", ":=", "ctxt", ".", "stateAndEntityForRequestAuthenticatedUser", "(", "r", ")", "\n", "return", "st", ",", "err", "\n", "}" ]

[ "stateForRequestAuthenticatedUser", "is", "like", "stateAndEntityForRequestAuthenticatedUser", "but", "doesn", "t", "return", "the", "entity", "." ]

[ "func", "(", "ctxt", "*", "httpContext", ")", "stateAndEntityForRequestAuthenticatedUser", "(", "r", "*", "http", ".", "Request", ")", "(", "*", "state", ".", "PooledState", ",", "state", ".", "Entity", ",", "error", ",", ")", "{", "return", "ctxt", ".", "stateForRequestAuthenticatedTag", "(", "r", ",", "names", ".", "UserTagKind", ")", "\n", "}" ]

[ "stateAndEntityForRequestAuthenticatedUser", "is", "like", "stateForRequestAuthenticated", "except", "that", "it", "also", "verifies", "that", "the", "authenticated", "entity", "is", "a", "user", "." ]

[ "func", "(", "ctxt", "*", "httpContext", ")", "stateForRequestAuthenticatedAgent", "(", "r", "*", "http", ".", "Request", ")", "(", "*", "state", ".", "PooledState", ",", "state", ".", "Entity", ",", "error", ",", ")", "{", "return", "ctxt", ".", "stateForRequestAuthenticatedTag", "(", "r", ",", "names", ".", "MachineTagKind", ",", "names", ".", "UnitTagKind", ",", "names", ".", "ApplicationTagKind", ")", "\n", "}" ]

[ "stateForRequestAuthenticatedAgent", "is", "like", "stateForRequestAuthenticated", "except", "that", "it", "also", "verifies", "that", "the", "authenticated", "entity", "is", "an", "agent", "." ]

[ "func", "(", "ctxt", "*", "httpContext", ")", "stateForRequestAuthenticatedTag", "(", "r", "*", "http", ".", "Request", ",", "kinds", "...", "string", ")", "(", "*", "state", ".", "PooledState", ",", "state", ".", "Entity", ",", "error", ",", ")", "{", "funcs", ":=", "make", "(", "[", "]", "common", ".", "GetAuthFunc", ",", "len", "(", "kinds", ")", ")", "\n", "for", "i", ",", "kind", ":=", "range", "kinds", "{", "funcs", "[", "i", "]", "=", "common", ".", "AuthFuncForTagKind", "(", "kind", ")", "\n", "}", "\n", "st", ",", "entity", ",", "err", ":=", "ctxt", ".", "stateForRequestAuthenticated", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "ok", ",", "err", ":=", "checkPermissions", "(", "entity", ".", "Tag", "(", ")", ",", "common", ".", "AuthAny", "(", "funcs", "...", ")", ")", ";", "!", "ok", "{", "st", ".", "Release", "(", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "return", "st", ",", "entity", ",", "nil", "\n", "}" ]

[ "stateForRequestAuthenticatedTag", "checks", "that", "the", "request", "is", "correctly", "authenticated", "and", "that", "the", "authenticated", "entity", "making", "the", "request", "is", "of", "one", "of", "the", "specified", "kinds", "." ]