Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "makeUploadVersion", "(", "vers", "version", ".", "Number", ",", "existing", "coretools", ".", "Versions", ")", "version", ".", "Number", "{", "vers", ".", "Build", "++", "\n", "for", "_", ",", "t", ":=", "range", "existing", "{", "if", "t", ".", "AgentVersion", "(", ")", ".", "Major", "!=", "vers", ".", "Major", "||", "t", ".", "AgentVersion", "(", ")", ".", "Minor", "!=", "vers", ".", "Minor", "||", "t", ".", "AgentVersion", "(", ")", ".", "Patch", "!=", "vers", ".", "Patch", "{", "continue", "\n", "}", "\n", "if", "t", ".", "AgentVersion", "(", ")", ".", "Build", ">=", "vers", ".", "Build", "{", "vers", ".", "Build", "=", "t", ".", "AgentVersion", "(", ")", ".", "Build", "+", "1", "\n", "}", "\n", "}", "\n", "return", "vers", "\n", "}" ]

[ "makeUploadVersion", "returns", "a", "copy", "of", "the", "supplied", "version", "with", "a", "build", "number", "higher", "than", "any", "of", "the", "supplied", "tools", "that", "share", "its", "major", "minor", "and", "patch", "." ]

[ "func", "Manifold", "(", "config", "ManifoldConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "ClockName", ",", "config", ".", "AgentName", ",", "config", ".", "TransportName", ",", "}", ",", "Start", ":", "config", ".", "start", ",", "Output", ":", "raftOutput", ",", "}", "\n", "}" ]

[ "Manifold", "returns", "a", "dependency", ".", "Manifold", "that", "will", "run", "a", "raft", "worker", "." ]

[ "func", "NewSuperCommand", "(", ")", "*", "Command", "{", "charmCmd", ":=", "&", "Command", "{", "SuperCommand", ":", "*", "cmd", ".", "NewSuperCommand", "(", "cmd", ".", "SuperCommandParams", "{", "Name", ":", "\"", "\"", ",", "Doc", ":", "resource", ".", "DeprecatedSince", "+", "charmDoc", ",", "UsagePrefix", ":", "\"", "\"", ",", "Purpose", ":", "resource", ".", "Deprecated", "+", "charmPurpose", ",", "}", ",", ")", ",", "}", "\n", "charmCmd", ".", "Register", "(", "resource", ".", "NewListCharmResourcesCommand", "(", "nil", ")", ")", "\n", "return", "charmCmd", "\n", "}" ]

[ "NewSuperCommand", "returns", "a", "new", "charm", "super", "-", "command", "." ]

[ "func", "RecordMachineInState", "(", "client", "ProvisioningClientAPI", ",", "machineParams", "params", ".", "AddMachineParams", ")", "(", "machineId", "string", ",", "err", "error", ")", "{", "results", ",", "err", ":=", "client", ".", "AddMachines", "(", "[", "]", "params", ".", "AddMachineParams", "{", "machineParams", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Currently, only one machine is added, but in future there may be several added in one call.", "machineInfo", ":=", "results", "[", "0", "]", "\n", "if", "machineInfo", ".", "Error", "!=", "nil", "{", "return", "\"", "\"", ",", "machineInfo", ".", "Error", "\n", "}", "\n", "return", "machineInfo", ".", "Machine", ",", "nil", "\n", "}" ]

[ "RecordMachineInState", "records", "and", "saves", "into", "the", "state", "machine", "the", "provisioned", "machine" ]

[ "func", "(", "c", "*", "Client", ")", "ModelGet", "(", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "result", ":=", "params", ".", "ModelConfigResults", "{", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "values", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "name", ",", "val", ":=", "range", "result", ".", "Config", "{", "values", "[", "name", "]", "=", "val", ".", "Value", "\n", "}", "\n", "return", "values", ",", "nil", "\n", "}" ]

[ "ModelGet", "returns", "all", "model", "settings", "." ]

[ "func", "(", "c", "*", "Client", ")", "ModelGetWithMetadata", "(", ")", "(", "config", ".", "ConfigValues", ",", "error", ")", "{", "result", ":=", "params", ".", "ModelConfigResults", "{", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "values", ":=", "make", "(", "config", ".", "ConfigValues", ")", "\n", "for", "name", ",", "val", ":=", "range", "result", ".", "Config", "{", "values", "[", "name", "]", "=", "config", ".", "ConfigValue", "{", "Value", ":", "val", ".", "Value", ",", "Source", ":", "val", ".", "Source", ",", "}", "\n", "}", "\n", "return", "values", ",", "nil", "\n", "}" ]

[ "ModelGetWithMetadata", "returns", "all", "model", "settings", "along", "with", "extra", "metadata", "like", "the", "source", "of", "the", "setting", "value", "." ]

[ "func", "(", "c", "*", "Client", ")", "ModelSet", "(", "config", "map", "[", "string", "]", "interface", "{", "}", ")", "error", "{", "args", ":=", "params", ".", "ModelSet", "{", "Config", ":", "config", "}", "\n", "return", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "}" ]

[ "ModelSet", "sets", "the", "given", "key", "-", "value", "pairs", "in", "the", "model", "." ]

[ "func", "(", "c", "*", "Client", ")", "ModelUnset", "(", "keys", "...", "string", ")", "error", "{", "args", ":=", "params", ".", "ModelUnset", "{", "Keys", ":", "keys", "}", "\n", "return", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "}" ]

[ "ModelUnset", "sets", "the", "given", "key", "-", "value", "pairs", "in", "the", "model", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetSLALevel", "(", "level", ",", "owner", "string", ",", "creds", "[", "]", "byte", ")", "error", "{", "args", ":=", "params", ".", "ModelSLA", "{", "ModelSLAInfo", ":", "params", ".", "ModelSLAInfo", "{", "Level", ":", "level", ",", "Owner", ":", "owner", ",", "}", ",", "Credentials", ":", "creds", ",", "}", "\n", "return", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "}" ]

[ "SetSLALevel", "sets", "the", "support", "level", "for", "the", "given", "model", "." ]

[ "func", "(", "c", "*", "Client", ")", "SLALevel", "(", ")", "(", "string", ",", "error", ")", "{", "var", "result", "params", ".", "StringResult", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "result", ".", "Result", ",", "nil", "\n", "}" ]

[ "SLALevel", "gets", "the", "support", "level", "for", "the", "given", "model", "." ]

[ "func", "(", "c", "*", "Client", ")", "Sequences", "(", ")", "(", "map", "[", "string", "]", "int", ",", "error", ")", "{", "if", "c", ".", "BestAPIVersion", "(", ")", "<", "2", "{", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "result", "params", ".", "ModelSequencesResult", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "result", ".", "Sequences", ",", "nil", "\n", "}" ]

[ "Sequences", "returns", "all", "sequence", "names", "and", "next", "values", "." ]

[ "func", "(", "api", "*", "API", ")", "Prune", "(", "p", "params", ".", "StatusHistoryPruneArgs", ")", "error", "{", "if", "!", "api", ".", "authorizer", ".", "AuthController", "(", ")", "{", "return", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "state", ".", "PruneStatusHistory", "(", "api", ".", "st", ",", "p", ".", "MaxHistoryTime", ",", "p", ".", "MaxHistoryMB", ")", "\n", "}" ]

[ "Prune", "endpoint", "removes", "status", "history", "entries", "until", "only", "the", "ones", "newer", "than", "now", "-", "p", ".", "MaxHistoryTime", "remain", "and", "the", "history", "is", "smaller", "than", "p", ".", "MaxHistoryMB", "." ]

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

[ "stepsFor245", "returns", "upgrade", "steps", "for", "Juju", "2", ".", "4", ".", "5" ]

[ "func", "CommandNames", "(", ")", "(", "names", "[", "]", "string", ")", "{", "for", "name", ":=", "range", "allEnabledCommands", "(", ")", "{", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "names", ")", "\n", "return", "\n", "}" ]

[ "CommandNames", "returns", "the", "names", "of", "all", "jujuc", "commands", "." ]

[ "func", "NewCommand", "(", "ctx", "Context", ",", "name", "string", ")", "(", "cmd", ".", "Command", ",", "error", ")", "{", "f", ":=", "allEnabledCommands", "(", ")", "[", "name", "]", "\n", "if", "f", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "command", ",", "err", ":=", "f", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "command", ",", "nil", "\n", "}" ]

[ "NewCommand", "returns", "an", "instance", "of", "the", "named", "Command", "initialized", "to", "execute", "against", "the", "supplied", "Context", "." ]

[ "func", "(", "j", "*", "Jujuc", ")", "Main", "(", "req", "Request", ",", "resp", "*", "exec", ".", "ExecResponse", ")", "error", "{", "if", "req", ".", "CommandName", "==", "\"", "\"", "{", "return", "badReqErrorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "req", ".", "Dir", ")", "{", "return", "badReqErrorf", "(", "\"", "\"", ")", "\n", "}", "\n", "c", ",", "err", ":=", "j", ".", "getCmd", "(", "req", ".", "ContextId", ",", "req", ".", "CommandName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "badReqErrorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "var", "stdin", "io", ".", "Reader", "\n", "if", "req", ".", "StdinSet", "{", "stdin", "=", "bytes", ".", "NewReader", "(", "req", ".", "Stdin", ")", "\n", "}", "else", "{", "// noStdinReader will error with ErrNoStdin", "// if its Read method is called.", "stdin", "=", "noStdinReader", "{", "}", "\n", "}", "\n", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n", "ctx", ":=", "&", "cmd", ".", "Context", "{", "Dir", ":", "req", ".", "Dir", ",", "Stdin", ":", "stdin", ",", "Stdout", ":", "&", "stdout", ",", "Stderr", ":", "&", "stderr", ",", "}", "\n", "j", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "j", ".", "mu", ".", "Unlock", "(", ")", "\n", "// Beware, reducing the log level of the following line will lead", "// to passwords leaking if passed as args.", "logger", ".", "Tracef", "(", "\"", "\"", ",", "req", ".", "CommandName", ",", "req", ".", "Args", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "req", ".", "CommandName", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "req", ".", "ContextId", ",", "req", ".", "Dir", ")", "\n", "wrapper", ":=", "&", "cmdWrapper", "{", "c", ",", "nil", "}", "\n", "resp", ".", "Code", "=", "cmd", ".", "Main", "(", "wrapper", ",", "ctx", ",", "req", ".", "Args", ")", "\n", "if", "errors", ".", "Cause", "(", "wrapper", ".", "err", ")", "==", "ErrNoStdin", "{", "return", "ErrNoStdin", "\n", "}", "\n", "resp", ".", "Stdout", "=", "stdout", ".", "Bytes", "(", ")", "\n", "resp", ".", "Stderr", "=", "stderr", ".", "Bytes", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Main", "runs", "the", "Command", "specified", "by", "req", "and", "fills", "in", "resp", ".", "A", "single", "command", "is", "run", "at", "a", "time", "." ]

[ "func", "NewServer", "(", "getCmd", "CmdGetter", ",", "socketPath", "string", ")", "(", "*", "Server", ",", "error", ")", "{", "server", ":=", "rpc", ".", "NewServer", "(", ")", "\n", "if", "err", ":=", "server", ".", "Register", "(", "&", "Jujuc", "{", "getCmd", ":", "getCmd", "}", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "listener", ",", "err", ":=", "sockets", ".", "Listen", "(", "socketPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "s", ":=", "&", "Server", "{", "socketPath", ":", "socketPath", ",", "listener", ":", "listener", ",", "server", ":", "server", ",", "closed", ":", "make", "(", "chan", "bool", ")", ",", "closing", ":", "make", "(", "chan", "bool", ")", ",", "}", "\n", "return", "s", ",", "nil", "\n", "}" ]

[ "NewServer", "creates", "an", "RPC", "server", "bound", "to", "socketPath", "which", "can", "execute", "remote", "command", "invocations", "against", "an", "appropriate", "Context", ".", "It", "will", "not", "actually", "do", "so", "until", "Run", "is", "called", "." ]

[ "func", "(", "config", "Config", ")", "Validate", "(", ")", "error", "{", "if", "config", ".", "RevisionUpdater", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Clock", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Period", "<=", "0", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "returns", "an", "error", "if", "the", "configuration", "cannot", "be", "expected", "to", "start", "a", "functional", "worker", "." ]

[ "func", "NewWorker", "(", "config", "Config", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "if", "err", ":=", "config", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "w", ":=", "&", "revisionUpdateWorker", "{", "config", ":", "config", ",", "}", "\n", "w", ".", "tomb", ".", "Go", "(", "w", ".", "loop", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "NewWorker", "returns", "a", "worker", "that", "calls", "UpdateLatestRevisions", "on", "the", "configured", "RevisionUpdater", "once", "when", "started", "and", "subsequently", "every", "Period", "." ]

[ "func", "NewEnviron", "(", "api", "NetworkingAPI", ",", "env", "commonProvider", ".", "OracleInstancer", ")", "*", "Environ", "{", "return", "&", "Environ", "{", "client", ":", "api", ",", "env", ":", "env", ",", "}", "\n", "}" ]

[ "NewEnviron", "returns", "a", "new", "instance", "of", "Environ" ]

[ "func", "(", "e", "Environ", ")", "getSubnetInfoAsMap", "(", ")", "(", "map", "[", "string", "]", "network", ".", "SubnetInfo", ",", "error", ")", "{", "subnets", ",", "err", ":=", "e", ".", "getSubnetInfo", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ret", ":=", "make", "(", "map", "[", "string", "]", "network", ".", "SubnetInfo", ",", "len", "(", "subnets", ")", ")", "\n", "for", "_", ",", "val", ":=", "range", "subnets", "{", "ret", "[", "string", "(", "val", ".", "ProviderId", ")", "]", "=", "val", "\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "getSubnetInfoAsMap", "will", "return", "the", "subnet", "information", "for", "the", "getSubnetInfo", "as", "a", "map", "rather", "than", "a", "slice" ]

[ "func", "(", "e", "Environ", ")", "getSubnetInfo", "(", ")", "(", "[", "]", "network", ".", "SubnetInfo", ",", "error", ")", "{", "networks", ",", "err", ":=", "e", ".", "client", ".", "AllIpNetworks", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "subnets", ":=", "make", "(", "[", "]", "network", ".", "SubnetInfo", ",", "len", "(", "networks", ".", "Result", ")", ")", "\n", "idx", ":=", "0", "\n", "for", "_", ",", "val", ":=", "range", "networks", ".", "Result", "{", "var", "spaceId", "network", ".", "Id", "\n", "if", "val", ".", "IpNetworkExchange", "!=", "nil", "{", "spaceId", "=", "network", ".", "Id", "(", "*", "val", ".", "IpNetworkExchange", ")", "\n", "}", "\n", "subnets", "[", "idx", "]", "=", "network", ".", "SubnetInfo", "{", "ProviderId", ":", "network", ".", "Id", "(", "val", ".", "Name", ")", ",", "CIDR", ":", "val", ".", "IpAddressPrefix", ",", "SpaceProviderId", ":", "spaceId", ",", "AvailabilityZones", ":", "[", "]", "string", "{", "\"", "\"", ",", "}", ",", "}", "\n", "idx", "++", "\n", "}", "\n", "return", "subnets", ",", "nil", "\n", "}" ]

[ "getSubnetInfo", "returns", "subnet", "information", "for", "all", "subnets", "known", "to", "the", "oracle", "provider" ]

[ "func", "(", "e", "Environ", ")", "NetworkInterfaces", "(", "ctx", "context", ".", "ProviderCallContext", ",", "instId", "instance", ".", "Id", ")", "(", "[", "]", "network", ".", "InterfaceInfo", ",", "error", ")", "{", "instance", ",", "err", ":=", "e", ".", "env", ".", "Details", "(", "instId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "instance", ".", "Networking", ")", "==", "0", "{", "return", "[", "]", "network", ".", "InterfaceInfo", "{", "}", ",", "nil", "\n", "}", "\n", "subnetInfo", ",", "err", ":=", "e", ".", "getSubnetInfoAsMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "nicAttributes", ":=", "e", ".", "getNicAttributes", "(", "instance", ")", "\n\n", "interfaces", ":=", "make", "(", "[", "]", "network", ".", "InterfaceInfo", ",", "0", ",", "len", "(", "instance", ".", "Networking", ")", ")", "\n", "idx", ":=", "0", "\n", "for", "nicName", ",", "nicObj", ":=", "range", "instance", ".", "Networking", "{", "// gsamfira: While the API may hold any alphanumeric NIC name", "// of up to 4 characters, inside an ubuntu instance,", "// the NIC will always be named eth0 (where 0 is the index of the NIC).", "// NICs inside the instance will be ordered in the same way the API", "// returns them; i.e. first element returned by the API will be eth0,", "// second element will be eth1 and so on. Sorting is done", "// alphanumerically it makes sense to use the name that will be", "// seen by the juju agent instead of the name that shows up", "// in the provider.", "// TODO (gsamfira): Check NIC naming in CentOS and Windows.", "name", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "idx", ")", ")", "\n", "deviceIndex", ":=", "idx", "\n\n", "idx", "+=", "1", "\n\n", "deviceAttributes", ",", "ok", ":=", "nicAttributes", "[", "nicName", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "nicName", ")", "\n", "}", "\n", "mac", ",", "ip", ",", "err", ":=", "GetMacAndIP", "(", "deviceAttributes", ".", "Address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "addr", ":=", "network", ".", "NewScopedAddress", "(", "ip", ",", "network", ".", "ScopeCloudLocal", ")", "\n", "nic", ":=", "network", ".", "InterfaceInfo", "{", "InterfaceName", ":", "name", ",", "DeviceIndex", ":", "deviceIndex", ",", "ProviderId", ":", "network", ".", "Id", "(", "deviceAttributes", ".", "Id", ")", ",", "MACAddress", ":", "mac", ",", "Address", ":", "addr", ",", "InterfaceType", ":", "network", ".", "EthernetInterface", ",", "}", "\n\n", "// gsamfira: VEthernet NICs are connected to shared networks", "// I have not found a way to interrogate details about the shared", "// networks available inside the oracle cloud. There is some", "// documentation on the matter here:", "//", "// https://docs.oracle.com/cloud-machine/latest/stcomputecs/ELUAP/GUID-8CBE0F4E-E376-4C93-BB56-884836273168.htm", "//", "// but I have not been able to get any information about the", "// shared networks using the resources described there.", "// We only populate Space information for NICs attached to", "// IPNetworks (user defined)", "if", "nicObj", ".", "GetType", "(", ")", "==", "common", ".", "VNic", "{", "nicSubnetDetails", ":=", "subnetInfo", "[", "deviceAttributes", ".", "Ipnetwork", "]", "\n", "nic", ".", "ProviderSpaceId", "=", "nicSubnetDetails", ".", "SpaceProviderId", "\n", "nic", ".", "ProviderSubnetId", "=", "nicSubnetDetails", ".", "ProviderId", "\n", "nic", ".", "CIDR", "=", "nicSubnetDetails", ".", "CIDR", "\n", "}", "\n", "interfaces", "=", "append", "(", "interfaces", ",", "nic", ")", "\n", "}", "\n\n", "return", "interfaces", ",", "nil", "\n", "}" ]

[ "NetworkInterfaces", "is", "defined", "on", "the", "environs", ".", "Networking", "interface", "." ]

[ "func", "(", "e", "Environ", ")", "getNicAttributes", "(", "instance", "response", ".", "Instance", ")", "map", "[", "string", "]", "response", ".", "Network", "{", "if", "instance", ".", "Attributes", ".", "Network", "==", "nil", "{", "return", "map", "[", "string", "]", "response", ".", "Network", "{", "}", "\n", "}", "\n", "n", ":=", "len", "(", "instance", ".", "Attributes", ".", "Network", ")", "\n", "ret", ":=", "make", "(", "map", "[", "string", "]", "response", ".", "Network", ",", "n", ")", "\n", "for", "name", ",", "obj", ":=", "range", "instance", ".", "Attributes", ".", "Network", "{", "tmp", ":=", "strings", ".", "TrimPrefix", "(", "name", ",", "`nimbula_vcable-`", ")", "\n", "ret", "[", "tmp", "]", "=", "obj", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "getNicAttributes", "returns", "all", "network", "cards", "attributes", "from", "a", "oracle", "instance" ]

[ "func", "(", "e", "*", "Environ", ")", "canAccessNetworkAPI", "(", ")", "(", "bool", ",", "error", ")", "{", "_", ",", "err", ":=", "e", ".", "client", ".", "AllAcls", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "if", "api", ".", "IsMethodNotAllowed", "(", "err", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "canAccessNetworkAPI", "checks", "whether", "or", "not", "we", "have", "access", "to", "the", "necessary", "API", "endpoints", "needed", "for", "spaces", "support" ]

[ "func", "(", "e", "Environ", ")", "SupportsSpaces", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "bool", ",", "error", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "access", ",", "err", ":=", "e", ".", "canAccessNetworkAPI", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "access", "{", "return", "true", ",", "nil", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "SupportsSpaces", "is", "defined", "on", "the", "environs", ".", "Networking", "interface", "." ]

[ "func", "(", "e", "Environ", ")", "SupportsSpaceDiscovery", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "bool", ",", "error", ")", "{", "access", ",", "err", ":=", "e", ".", "canAccessNetworkAPI", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "access", "{", "return", "true", ",", "nil", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "SupportsSpaceDiscovery", "is", "defined", "on", "the", "environs", ".", "Networking", "interface", "." ]

[ "func", "(", "e", "Environ", ")", "Spaces", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "network", ".", "SpaceInfo", ",", "error", ")", "{", "networks", ",", "err", ":=", "e", ".", "getSubnetInfo", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "exchanges", ":=", "map", "[", "string", "]", "network", ".", "SpaceInfo", "{", "}", "\n", "for", "_", ",", "val", ":=", "range", "networks", "{", "if", "val", ".", "SpaceProviderId", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "string", "(", "val", ".", "ProviderId", ")", ",", "string", "(", "val", ".", "SpaceProviderId", ")", ")", "\n", "providerID", ":=", "string", "(", "val", ".", "SpaceProviderId", ")", "\n", "tmp", ":=", "strings", ".", "Split", "(", "providerID", ",", "`/`", ")", "\n", "name", ":=", "tmp", "[", "len", "(", "tmp", ")", "-", "1", "]", "\n", "// Oracle allows us to attach an IP network to a space belonging to", "// another user using the web portal. We recompose the provider ID", "// (which is unique) and compare to the provider ID of the space.", "// If they match, the space belongs to us", "tmpProviderId", ":=", "e", ".", "client", ".", "ComposeName", "(", "name", ")", "\n", "if", "tmpProviderId", "!=", "providerID", "{", "continue", "\n", "}", "\n", "if", "space", ",", "ok", ":=", "exchanges", "[", "name", "]", ";", "!", "ok", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "string", "(", "val", ".", "ProviderId", ")", ")", "\n", "exchanges", "[", "name", "]", "=", "network", ".", "SpaceInfo", "{", "Name", ":", "name", ",", "ProviderId", ":", "val", ".", "SpaceProviderId", ",", "Subnets", ":", "[", "]", "network", ".", "SubnetInfo", "{", "val", ",", "}", ",", "}", "\n", "}", "else", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "string", "(", "val", ".", "ProviderId", ")", ",", "space", ".", "Name", ")", "\n", "space", ".", "Subnets", "=", "append", "(", "space", ".", "Subnets", ",", "val", ")", "\n", "exchanges", "[", "name", "]", "=", "space", "\n", "}", "\n\n", "}", "\n", "var", "ret", "[", "]", "network", ".", "SpaceInfo", "\n", "for", "_", ",", "val", ":=", "range", "exchanges", "{", "ret", "=", "append", "(", "ret", ",", "val", ")", "\n", "}", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "ret", ")", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "Spaces", "is", "defined", "on", "the", "environs", ".", "Networking", "interface", "." ]

[ "func", "(", "hdr", "*", "Header", ")", "IsRequest", "(", ")", "bool", "{", "return", "hdr", ".", "Request", ".", "Type", "!=", "\"", "\"", "||", "hdr", ".", "Request", ".", "Action", "!=", "\"", "\"", "\n", "}" ]

[ "IsRequest", "returns", "whether", "the", "header", "represents", "an", "RPC", "request", ".", "If", "it", "is", "not", "a", "request", "it", "is", "a", "response", "." ]

[ "func", "NewConn", "(", "codec", "Codec", ",", "factory", "RecorderFactory", ")", "*", "Conn", "{", "return", "&", "Conn", "{", "codec", ":", "codec", ",", "clientPending", ":", "make", "(", "map", "[", "uint64", "]", "*", "Call", ")", ",", "recorderFactory", ":", "ensureFactory", "(", "factory", ")", ",", "}", "\n", "}" ]

[ "NewConn", "creates", "a", "new", "connection", "that", "uses", "the", "given", "codec", "for", "transport", "but", "it", "does", "not", "start", "it", ".", "Conn", ".", "Start", "must", "be", "called", "before", "any", "requests", "are", "sent", "or", "received", ".", "If", "recorderFactory", "is", "non", "-", "nil", "it", "will", "be", "called", "to", "get", "a", "new", "recorder", "for", "every", "request", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "ServeRoot", "(", "root", "Root", ",", "factory", "RecorderFactory", ",", "transformErrors", "func", "(", "error", ")", "error", ")", "{", "conn", ".", "serve", "(", "root", ",", "factory", ",", "transformErrors", ")", "\n", "}" ]

[ "ServeRoot", "is", "like", "Serve", "except", "that", "it", "gives", "the", "root", "object", "dynamic", "control", "over", "what", "methods", "are", "available", "instead", "of", "using", "reflection", "on", "the", "type", ".", "The", "server", "executes", "each", "client", "request", "by", "calling", "FindMethod", "to", "obtain", "a", "method", "to", "invoke", ".", "It", "invokes", "that", "method", "with", "the", "request", "parameters", "possibly", "returning", "some", "result", ".", "The", "Kill", "method", "will", "be", "called", "when", "the", "connection", "is", "closed", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "Close", "(", ")", "error", "{", "conn", ".", "mutex", ".", "Lock", "(", ")", "\n", "if", "conn", ".", "closing", "{", "conn", ".", "mutex", ".", "Unlock", "(", ")", "\n", "// Golang's net/rpc returns rpc.ErrShutdown if you ask to close", "// a closing or shutdown connection. Our choice is that Close", "// is an idempotent way to ask for resources to be released and", "// isn't a failure if called multiple times.", "return", "nil", "\n", "}", "\n", "conn", ".", "closing", "=", "true", "\n", "if", "conn", ".", "root", "!=", "nil", "{", "// Kill calls down into the resources to stop all the resources which", "// includes watchers. The watches need to be killed in order for their", "// API methods to return, otherwise they are just waiting.", "conn", ".", "root", ".", "Kill", "(", ")", "\n", "}", "\n", "conn", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "// Wait for any outstanding server requests to complete", "// and write their replies before closing the codec. We", "// cancel the context so that any requests that would", "// block will be notified that the server is shutting", "// down.", "conn", ".", "cancelContext", "(", ")", "\n", "conn", ".", "srvPending", ".", "Wait", "(", ")", "\n\n", "conn", ".", "mutex", ".", "Lock", "(", ")", "\n", "if", "conn", ".", "root", "!=", "nil", "{", "// It is possible that since we last Killed the root, other resources", "// may have been added during some of the pending call resoulutions.", "// So to release these resources, double tap the root.", "conn", ".", "root", ".", "Kill", "(", ")", "\n", "}", "\n", "conn", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "// Closing the codec should cause the input loop to terminate.", "if", "err", ":=", "conn", ".", "codec", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "<-", "conn", ".", "dead", "\n\n", "return", "conn", ".", "inputLoopError", "\n", "}" ]

[ "Close", "closes", "the", "connection", "and", "its", "underlying", "codec", ";", "it", "returns", "when", "all", "requests", "have", "been", "terminated", ".", "If", "the", "connection", "is", "serving", "requests", "and", "the", "root", "value", "implements", "the", "Killer", "interface", "its", "Kill", "method", "will", "be", "called", ".", "The", "codec", "will", "then", "be", "closed", "only", "when", "all", "its", "outstanding", "server", "calls", "have", "completed", ".", "Calling", "Close", "multiple", "times", "is", "not", "an", "error", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "input", "(", ")", "{", "err", ":=", "conn", ".", "loop", "(", ")", "\n", "conn", ".", "sending", ".", "Lock", "(", ")", "\n", "defer", "conn", ".", "sending", ".", "Unlock", "(", ")", "\n", "conn", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "conn", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "conn", ".", "closing", "||", "errors", ".", "Cause", "(", "err", ")", "==", "io", ".", "EOF", "{", "err", "=", "ErrShutdown", "\n", "}", "else", "{", "// Make the error available for Conn.Close to see.", "conn", ".", "inputLoopError", "=", "err", "\n", "}", "\n", "// Terminate all client requests.", "for", "_", ",", "call", ":=", "range", "conn", ".", "clientPending", "{", "call", ".", "Error", "=", "err", "\n", "call", ".", "done", "(", ")", "\n", "}", "\n", "conn", ".", "clientPending", "=", "nil", "\n", "conn", ".", "shutdown", "=", "true", "\n", "close", "(", "conn", ".", "dead", ")", "\n", "}" ]

[ "input", "reads", "messages", "from", "the", "connection", "and", "handles", "them", "appropriately", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "loop", "(", ")", "error", "{", "defer", "conn", ".", "cancelContext", "(", ")", "\n", "for", "{", "var", "hdr", "Header", "\n", "err", ":=", "conn", ".", "codec", ".", "ReadHeader", "(", "&", "hdr", ")", "\n", "switch", "{", "case", "errors", ".", "Cause", "(", "err", ")", "==", "io", ".", "EOF", ":", "// handle sentinel error specially", "return", "err", "\n", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "case", "hdr", ".", "IsRequest", "(", ")", ":", "if", "err", ":=", "conn", ".", "handleRequest", "(", "&", "hdr", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "hdr", ")", "\n", "}", "\n", "default", ":", "if", "err", ":=", "conn", ".", "handleResponse", "(", "&", "hdr", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "hdr", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "loop", "implements", "the", "looping", "part", "of", "Conn", ".", "input", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "bindRequest", "(", "hdr", "*", "Header", ")", "(", "boundRequest", ",", "error", ")", "{", "conn", ".", "mutex", ".", "Lock", "(", ")", "\n", "root", ":=", "conn", ".", "root", "\n", "transformErrors", ":=", "conn", ".", "transformErrors", "\n", "conn", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "root", "==", "nil", "{", "return", "boundRequest", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "caller", ",", "err", ":=", "root", ".", "FindMethod", "(", "hdr", ".", "Request", ".", "Type", ",", "hdr", ".", "Request", ".", "Version", ",", "hdr", ".", "Request", ".", "Action", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "rpcreflect", ".", "CallNotImplementedError", ")", ";", "ok", "{", "err", "=", "&", "serverError", "{", "error", ":", "err", ",", "}", "\n", "}", "else", "{", "err", "=", "transformErrors", "(", "err", ")", "\n", "}", "\n", "return", "boundRequest", "{", "}", ",", "err", "\n", "}", "\n", "return", "boundRequest", "{", "MethodCaller", ":", "caller", ",", "transformErrors", ":", "transformErrors", ",", "hdr", ":", "*", "hdr", ",", "}", ",", "nil", "\n", "}" ]

[ "bindRequest", "searches", "for", "methods", "implementing", "the", "request", "held", "in", "the", "given", "header", "and", "returns", "a", "boundRequest", "that", "can", "call", "those", "methods", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "runRequest", "(", "req", "boundRequest", ",", "arg", "reflect", ".", "Value", ",", "version", "int", ",", "recorder", "Recorder", ",", ")", "{", "// If the request causes a panic, ensure we log that before closing the connection.", "defer", "func", "(", ")", "{", "if", "panicResult", ":=", "recover", "(", ")", ";", "panicResult", "!=", "nil", "{", "logger", ".", "Criticalf", "(", "\"", "\\n", "\"", ",", "req", ",", "arg", ",", "panicResult", ",", "string", "(", "debug", ".", "Stack", "(", ")", ")", ")", "\n", "conn", ".", "writeErrorResponse", "(", "&", "req", ".", "hdr", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "panicResult", ")", ",", "recorder", ")", "\n", "}", "\n", "}", "(", ")", "\n", "defer", "conn", ".", "srvPending", ".", "Done", "(", ")", "\n\n", "// Create a request-specific context, cancelled when the", "// request returns.", "//", "// TODO(axw) provide a means for clients to cancel a request.", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "conn", ".", "context", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "rv", ",", "err", ":=", "req", ".", "Call", "(", "ctx", ",", "req", ".", "hdr", ".", "Request", ".", "Id", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "conn", ".", "writeErrorResponse", "(", "&", "req", ".", "hdr", ",", "req", ".", "transformErrors", "(", "err", ")", ",", "recorder", ")", "\n", "}", "else", "{", "hdr", ":=", "&", "Header", "{", "RequestId", ":", "req", ".", "hdr", ".", "RequestId", ",", "Version", ":", "version", ",", "}", "\n", "var", "rvi", "interface", "{", "}", "\n", "if", "rv", ".", "IsValid", "(", ")", "{", "rvi", "=", "rv", ".", "Interface", "(", ")", "\n", "}", "else", "{", "rvi", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "if", "err", ":=", "recorder", ".", "HandleReply", "(", "req", ".", "hdr", ".", "Request", ",", "hdr", ",", "rvi", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "hdr", ",", "err", ",", "err", ")", "\n", "}", "\n", "conn", ".", "sending", ".", "Lock", "(", ")", "\n", "err", "=", "conn", ".", "codec", ".", "WriteMessage", "(", "hdr", ",", "rvi", ")", "\n", "conn", ".", "sending", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "// If the message failed due to the other end closing the socket, that", "// is expected when an agent restarts so no need to log an error.", "// The error type here is errors.errorString so all we can do is a match", "// on the error string content.", "msg", ":=", "err", ".", "Error", "(", ")", "\n", "if", "!", "strings", ".", "Contains", "(", "msg", ",", "\"", "\"", ")", "&&", "!", "strings", ".", "Contains", "(", "msg", ",", "\"", "\"", ")", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "runRequest", "runs", "the", "given", "request", "and", "sends", "the", "reply", "." ]

[ "func", "(", "r", "*", "actionsResolver", ")", "NextOp", "(", "localState", "resolver", ".", "LocalState", ",", "remoteState", "remotestate", ".", "Snapshot", ",", "opFactory", "operation", ".", "Factory", ",", ")", "(", "operation", ".", "Operation", ",", "error", ")", "{", "// If there are no operation left to be run, then we cannot return the", "// error signaling such here, we must first check to see if an action is", "// already running (that has been interrupted) before we declare that", "// there is nothing to do.", "nextAction", ",", "err", ":=", "nextAction", "(", "remoteState", ".", "Actions", ",", "localState", ".", "CompletedActions", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "resolver", ".", "ErrNoOperation", "{", "return", "nil", ",", "err", "\n", "}", "\n", "switch", "localState", ".", "Kind", "{", "case", "operation", ".", "RunHook", ":", "// We can still run actions if the unit is in a hook error state.", "if", "localState", ".", "Step", "==", "operation", ".", "Pending", "&&", "err", "==", "nil", "{", "return", "opFactory", ".", "NewAction", "(", "nextAction", ")", "\n", "}", "\n", "case", "operation", ".", "RunAction", ":", "if", "localState", ".", "Hook", "!=", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "localState", ".", "ActionId", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "localState", ".", "Hook", ".", "Kind", ")", "\n", "return", "opFactory", ".", "NewSkipHook", "(", "*", "localState", ".", "Hook", ")", "\n", "}", "else", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "operation", ".", "RunAction", ")", "\n\n", "// If the next action is the same as what the uniter is", "// currently running then this means that the uniter was", "// some how interrupted (killed) when running the action", "// and before updating the remote state to indicate that", "// the action was completed. The only safe thing to do", "// is fail the action, since rerunning an arbitrary", "// command can potentially be hazardous.", "if", "nextAction", "==", "*", "localState", ".", "ActionId", "{", "return", "opFactory", ".", "NewFailAction", "(", "*", "localState", ".", "ActionId", ")", "\n", "}", "\n\n", "// If the next action is different then what the uniter", "// is currently running, then the uniter may have been", "// interrupted while running the action but the remote", "// state was updated. Thus, the semantics of", "// (re)preparing the running operation should move the", "// uniter's state along safely. Thus, we return the", "// running action.", "return", "opFactory", ".", "NewAction", "(", "*", "localState", ".", "ActionId", ")", "\n", "}", "\n", "case", "operation", ".", "Continue", ":", "if", "err", "!=", "resolver", ".", "ErrNoOperation", "{", "return", "opFactory", ".", "NewAction", "(", "nextAction", ")", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "resolver", ".", "ErrNoOperation", "\n", "}" ]

[ "NextOp", "implements", "the", "resolver", ".", "Resolver", "interface", "." ]

[ "func", "(", "p", "Phase", ")", "String", "(", ")", "string", "{", "i", ":=", "int", "(", "p", ")", "\n", "if", "i", ">=", "0", "&&", "i", "<", "len", "(", "phaseNames", ")", "{", "return", "phaseNames", "[", "i", "]", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "String", "returns", "the", "name", "of", "an", "model", "migration", "phase", "constant", "." ]

[ "func", "(", "p", "Phase", ")", "CanTransitionTo", "(", "targetPhase", "Phase", ")", "bool", "{", "nextPhases", ",", "exists", ":=", "validTransitions", "[", "p", "]", "\n", "if", "!", "exists", "{", "return", "false", "\n", "}", "\n", "for", "_", ",", "nextPhase", ":=", "range", "nextPhases", "{", "if", "nextPhase", "==", "targetPhase", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "CanTransitionTo", "returns", "true", "if", "the", "given", "phase", "is", "a", "valid", "next", "model", "migration", "phase", "." ]

[ "func", "(", "p", "Phase", ")", "IsTerminal", "(", ")", "bool", "{", "for", "_", ",", "t", ":=", "range", "terminalPhases", "{", "if", "p", "==", "t", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsTerminal", "returns", "true", "if", "the", "phase", "is", "one", "which", "signifies", "the", "end", "of", "a", "migration", "." ]

[ "func", "(", "p", "Phase", ")", "IsRunning", "(", ")", "bool", "{", "if", "p", ".", "IsTerminal", "(", ")", "{", "return", "false", "\n", "}", "\n", "switch", "p", "{", "case", "QUIESCE", ",", "IMPORT", ",", "VALIDATION", ",", "SUCCESS", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsRunning", "returns", "true", "if", "the", "phase", "indicates", "the", "migration", "is", "active", "and", "up", "to", "or", "at", "the", "SUCCESS", "phase", ".", "It", "returns", "false", "if", "the", "phase", "is", "one", "of", "the", "final", "cleanup", "phases", "or", "indicates", "an", "failed", "migration", "." ]

[ "func", "ParsePhase", "(", "target", "string", ")", "(", "Phase", ",", "bool", ")", "{", "for", "p", ",", "name", ":=", "range", "phaseNames", "{", "if", "target", "==", "name", "{", "return", "Phase", "(", "p", ")", ",", "true", "\n", "}", "\n", "}", "\n", "return", "UNKNOWN", ",", "false", "\n", "}" ]

[ "ParsePhase", "converts", "a", "string", "model", "migration", "phase", "name", "to", "its", "constant", "value", "." ]

[ "func", "Manifold", "(", "config", "ManifoldConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "AgentName", "}", ",", "Start", ":", "func", "(", "context", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "if", "config", ".", "AgentConfigChanged", "==", "nil", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "a", "agent", ".", "Agent", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "AgentName", ",", "&", "a", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "w", ":=", "&", "apiconfigwatcher", "{", "agent", ":", "a", ",", "agentConfigChanged", ":", "config", ".", "AgentConfigChanged", ",", "addrs", ":", "getAPIAddresses", "(", "a", ")", ",", "}", "\n", "w", ".", "tomb", ".", "Go", "(", "w", ".", "loop", ")", "\n", "return", "w", ",", "nil", "\n", "}", ",", "}", "\n", "}" ]

[ "Manifold", "returns", "a", "dependency", ".", "Manifold", "which", "wraps", "an", "agent", "s", "voyeur", ".", "Value", "which", "is", "set", "whenever", "the", "agent", "config", "is", "changed", ".", "When", "the", "API", "server", "addresses", "in", "the", "config", "change", "the", "manifold", "will", "bounce", "itself", ".", "The", "manifold", "is", "intended", "to", "be", "a", "dependency", "for", "the", "api", "-", "caller", "manifold", "and", "is", "required", "to", "support", "model", "migrations", "." ]

[ "func", "NewAddCommand", "(", ")", "cmd", ".", "Command", "{", "cmd", ":=", "&", "addCommand", "{", "}", "\n", "cmd", ".", "newAPIFunc", "=", "func", "(", ")", "(", "StorageAddAPI", ",", "error", ")", "{", "return", "cmd", ".", "NewStorageAPI", "(", ")", "\n", "}", "\n", "return", "modelcmd", ".", "Wrap", "(", "cmd", ")", "\n", "}" ]

[ "NewAddCommand", "returns", "a", "command", "used", "to", "add", "unit", "storage", "." ]

[ "func", "ParseHarvestMode", "(", "description", "string", ")", "(", "HarvestMode", ",", "error", ")", "{", "description", "=", "strings", ".", "ToLower", "(", "description", ")", "\n", "for", "method", ",", "descr", ":=", "range", "harvestingMethodToFlag", "{", "if", "description", "==", "descr", "{", "return", "method", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "description", ")", "\n", "}" ]

[ "ParseHarvestMode", "parses", "description", "of", "harvesting", "method", "and", "returns", "the", "representation", "." ]

[ "func", "(", "method", "HarvestMode", ")", "String", "(", ")", "string", "{", "if", "description", ",", "ok", ":=", "harvestingMethodToFlag", "[", "method", "]", ";", "ok", "{", "return", "description", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "String", "returns", "the", "description", "of", "the", "harvesting", "mode", "." ]

[ "func", "PreferredSeries", "(", "cfg", "HasDefaultSeries", ")", "string", "{", "if", "series", ",", "ok", ":=", "cfg", ".", "DefaultSeries", "(", ")", ";", "ok", "{", "return", "series", "\n", "}", "\n", "return", "jujuversion", ".", "SupportedLTS", "(", ")", "\n", "}" ]

[ "PreferredSeries", "returns", "the", "preferred", "series", "to", "use", "when", "a", "charm", "does", "not", "explicitly", "specify", "a", "series", "." ]

[ "func", "ProcessDeprecatedAttributes", "(", "attrs", "map", "[", "string", "]", "interface", "{", "}", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "processedAttrs", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "len", "(", "attrs", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "attrs", "{", "processedAttrs", "[", "k", "]", "=", "v", "\n", "}", "\n", "// No deprecated attributes at the moment.", "return", "processedAttrs", "\n", "}" ]

[ "ProcessDeprecatedAttributes", "gathers", "any", "deprecated", "attributes", "in", "attrs", "and", "adds", "or", "replaces", "them", "with", "new", "name", "value", "pairs", "for", "the", "replacement", "attrs", ".", "Ths", "ensures", "that", "older", "versions", "of", "Juju", "which", "require", "that", "deprecated", "attribute", "values", "still", "be", "used", "will", "work", "as", "expected", "." ]

[ "func", "CoerceForStorage", "(", "attrs", "map", "[", "string", "]", "interface", "{", "}", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "coercedAttrs", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "len", "(", "attrs", ")", ")", "\n", "for", "attrName", ",", "attrValue", ":=", "range", "attrs", "{", "if", "attrName", "==", "ResourceTagsKey", "{", "// Resource Tags are specified by the user as a string but transformed", "// to a map when config is parsed. We want to store as a string.", "var", "tagsSlice", "[", "]", "string", "\n", "if", "tags", ",", "ok", ":=", "attrValue", ".", "(", "map", "[", "string", "]", "string", ")", ";", "ok", "{", "for", "resKey", ",", "resValue", ":=", "range", "tags", "{", "tagsSlice", "=", "append", "(", "tagsSlice", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "resKey", ",", "resValue", ")", ")", "\n", "}", "\n", "attrValue", "=", "strings", ".", "Join", "(", "tagsSlice", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "coercedAttrs", "[", "attrName", "]", "=", "attrValue", "\n", "}", "\n", "return", "coercedAttrs", "\n", "}" ]

[ "CoerceForStorage", "transforms", "attributes", "prior", "to", "being", "saved", "in", "a", "persistent", "store", "." ]

[ "func", "ensureStringMaps", "(", "in", "string", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "userDataMap", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "err", ":=", "yaml", ".", "Unmarshal", "(", "[", "]", "byte", "(", "in", ")", ",", "&", "userDataMap", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "out", ",", "err", ":=", "utils", ".", "ConformYAML", "(", "userDataMap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "out", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ",", "nil", "\n", "}" ]

[ "ensureStringMaps", "takes", "in", "a", "string", "and", "returns", "YAML", "in", "a", "map", "where", "all", "keys", "of", "any", "nested", "maps", "are", "strings", "." ]

[ "func", "(", "c", "*", "Config", ")", "asString", "(", "name", "string", ")", "string", "{", "value", ",", "_", ":=", "c", ".", "defined", "[", "name", "]", ".", "(", "string", ")", "\n", "return", "value", "\n", "}" ]

[ "asString", "is", "a", "private", "helper", "method", "to", "keep", "the", "ugly", "string", "casting", "in", "once", "place", ".", "It", "returns", "the", "given", "named", "attribute", "as", "a", "string", "returning", "if", "it", "isn", "t", "found", "." ]

[ "func", "(", "c", "*", "Config", ")", "DefaultSeries", "(", ")", "(", "string", ",", "bool", ")", "{", "s", ",", "ok", ":=", "c", ".", "defined", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n", "switch", "s", ":=", "s", ".", "(", "type", ")", "{", "case", "string", ":", "return", "s", ",", "s", "!=", "\"", "\"", "\n", "default", ":", "logger", ".", "Errorf", "(", "\"", "\"", ",", "s", ")", "\n", "return", "\"", "\"", ",", "false", "\n", "}", "\n", "}" ]

[ "DefaultSeries", "returns", "the", "configured", "default", "Ubuntu", "series", "for", "the", "environment", "and", "whether", "the", "default", "series", "was", "explicitly", "configured", "on", "the", "environment", "." ]

[ "func", "(", "c", "*", "Config", ")", "AuthorizedKeys", "(", ")", "string", "{", "value", ",", "_", ":=", "c", ".", "defined", "[", "AuthorizedKeysKey", "]", ".", "(", "string", ")", "\n", "return", "value", "\n", "}" ]

[ "AuthorizedKeys", "returns", "the", "content", "for", "ssh", "s", "authorized_keys", "file", "." ]

[ "func", "(", "c", "*", "Config", ")", "ProxySSH", "(", ")", "bool", "{", "value", ",", "_", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ".", "(", "bool", ")", "\n", "return", "value", "\n", "}" ]

[ "ProxySSH", "returns", "a", "flag", "indicating", "whether", "SSH", "commands", "should", "be", "proxied", "through", "the", "API", "server", "." ]

[ "func", "(", "c", "*", "Config", ")", "NetBondReconfigureDelay", "(", ")", "int", "{", "value", ",", "_", ":=", "c", ".", "defined", "[", "NetBondReconfigureDelayKey", "]", ".", "(", "int", ")", "\n", "return", "value", "\n", "}" ]

[ "NetBondReconfigureDelay", "returns", "the", "duration", "in", "seconds", "that", "should", "be", "passed", "to", "the", "bridge", "script", "when", "bridging", "bonded", "interfaces", "." ]

[ "func", "(", "c", "*", "Config", ")", "LegacyProxySettings", "(", ")", "proxy", ".", "Settings", "{", "return", "proxy", ".", "Settings", "{", "Http", ":", "c", ".", "HTTPProxy", "(", ")", ",", "Https", ":", "c", ".", "HTTPSProxy", "(", ")", ",", "Ftp", ":", "c", ".", "FTPProxy", "(", ")", ",", "NoProxy", ":", "c", ".", "NoProxy", "(", ")", ",", "}", "\n", "}" ]

[ "LegacyProxySettings", "returns", "all", "four", "proxy", "settings", ";", "http", "https", "ftp", "and", "no", "proxy", ".", "These", "are", "considered", "legacy", "as", "using", "these", "values", "will", "cause", "the", "environment", "to", "be", "updated", "which", "has", "shown", "to", "not", "work", "in", "many", "cases", ".", "It", "is", "being", "kept", "to", "avoid", "breaking", "environments", "where", "it", "is", "sufficient", "." ]

[ "func", "(", "c", "*", "Config", ")", "HasLegacyProxy", "(", ")", "bool", "{", "// We exclude the no proxy value as it has default value.", "return", "c", ".", "HTTPProxy", "(", ")", "!=", "\"", "\"", "||", "c", ".", "HTTPSProxy", "(", ")", "!=", "\"", "\"", "||", "c", ".", "FTPProxy", "(", ")", "!=", "\"", "\"", "\n", "}" ]

[ "HasLegacyProxy", "returns", "true", "if", "there", "is", "any", "proxy", "set", "using", "the", "old", "legacy", "proxy", "keys", "." ]

[ "func", "(", "c", "*", "Config", ")", "HasJujuProxy", "(", ")", "bool", "{", "// We exclude the no proxy value as it has default value.", "return", "c", ".", "JujuHTTPProxy", "(", ")", "!=", "\"", "\"", "||", "c", ".", "JujuHTTPSProxy", "(", ")", "!=", "\"", "\"", "||", "c", ".", "JujuFTPProxy", "(", ")", "!=", "\"", "\"", "\n", "}" ]

[ "HasJujuProxy", "returns", "true", "if", "there", "is", "any", "proxy", "set", "using", "the", "new", "juju", "-", "proxy", "keys", "." ]

[ "func", "(", "c", "*", "Config", ")", "JujuProxySettings", "(", ")", "proxy", ".", "Settings", "{", "return", "proxy", ".", "Settings", "{", "Http", ":", "c", ".", "JujuHTTPProxy", "(", ")", ",", "Https", ":", "c", ".", "JujuHTTPSProxy", "(", ")", ",", "Ftp", ":", "c", ".", "JujuFTPProxy", "(", ")", ",", "NoProxy", ":", "c", ".", "JujuNoProxy", "(", ")", ",", "}", "\n", "}" ]

[ "JujuProxySettings", "returns", "all", "four", "proxy", "settings", "that", "have", "been", "set", "using", "the", "juju", "-", "prefixed", "proxy", "settings", ".", "These", "values", "determine", "the", "current", "best", "practice", "for", "proxies", "." ]

[ "func", "addSchemeIfMissing", "(", "defaultScheme", "string", ",", "url", "string", ")", "string", "{", "if", "url", "!=", "\"", "\"", "&&", "!", "strings", ".", "Contains", "(", "url", ",", "\"", "\"", ")", "{", "url", "=", "defaultScheme", "+", "\"", "\"", "+", "url", "\n", "}", "\n", "return", "url", "\n", "}" ]

[ "addSchemeIfMissing", "adds", "a", "scheme", "to", "a", "URL", "if", "it", "is", "missing" ]

[ "func", "(", "c", "*", "Config", ")", "AptProxySettings", "(", ")", "proxy", ".", "Settings", "{", "return", "proxy", ".", "Settings", "{", "Http", ":", "c", ".", "AptHTTPProxy", "(", ")", ",", "Https", ":", "c", ".", "AptHTTPSProxy", "(", ")", ",", "Ftp", ":", "c", ".", "AptFTPProxy", "(", ")", ",", "NoProxy", ":", "c", ".", "AptNoProxy", "(", ")", ",", "}", "\n", "}" ]

[ "AptProxySettings", "returns", "all", "three", "proxy", "settings", ";", "http", "https", "and", "ftp", "." ]

[ "func", "(", "c", "*", "Config", ")", "AptHTTPProxy", "(", ")", "string", "{", "return", "addSchemeIfMissing", "(", "\"", "\"", ",", "c", ".", "getWithFallback", "(", "AptHTTPProxyKey", ",", "JujuHTTPProxyKey", ",", "HTTPProxyKey", ")", ")", "\n", "}" ]

[ "AptHTTPProxy", "returns", "the", "apt", "http", "proxy", "for", "the", "environment", ".", "Falls", "back", "to", "the", "default", "http", "-", "proxy", "if", "not", "specified", "." ]

[ "func", "(", "c", "*", "Config", ")", "AptHTTPSProxy", "(", ")", "string", "{", "return", "addSchemeIfMissing", "(", "\"", "\"", ",", "c", ".", "getWithFallback", "(", "AptHTTPSProxyKey", ",", "JujuHTTPSProxyKey", ",", "HTTPSProxyKey", ")", ")", "\n", "}" ]

[ "AptHTTPSProxy", "returns", "the", "apt", "https", "proxy", "for", "the", "environment", ".", "Falls", "back", "to", "the", "default", "https", "-", "proxy", "if", "not", "specified", "." ]

[ "func", "(", "c", "*", "Config", ")", "AptFTPProxy", "(", ")", "string", "{", "return", "addSchemeIfMissing", "(", "\"", "\"", ",", "c", ".", "getWithFallback", "(", "AptFTPProxyKey", ",", "JujuFTPProxyKey", ",", "FTPProxyKey", ")", ")", "\n", "}" ]

[ "AptFTPProxy", "returns", "the", "apt", "ftp", "proxy", "for", "the", "environment", ".", "Falls", "back", "to", "the", "default", "ftp", "-", "proxy", "if", "not", "specified", "." ]

[ "func", "(", "c", "*", "Config", ")", "AptNoProxy", "(", ")", "string", "{", "value", ":=", "c", ".", "asString", "(", "AptNoProxyKey", ")", "\n", "if", "value", "==", "\"", "\"", "{", "if", "c", ".", "HasLegacyProxy", "(", ")", "{", "value", "=", "c", ".", "asString", "(", "NoProxyKey", ")", "\n", "}", "else", "{", "value", "=", "c", ".", "asString", "(", "JujuNoProxyKey", ")", "\n", "}", "\n", "}", "\n", "return", "value", "\n", "}" ]

[ "AptNoProxy", "returns", "the", "apt", "-", "no", "-", "proxy", "for", "the", "environment", "." ]

[ "func", "(", "c", "*", "Config", ")", "SnapProxySettings", "(", ")", "proxy", ".", "Settings", "{", "return", "proxy", ".", "Settings", "{", "Http", ":", "c", ".", "SnapHTTPProxy", "(", ")", ",", "Https", ":", "c", ".", "SnapHTTPSProxy", "(", ")", ",", "}", "\n", "}" ]

[ "SnapProxySettings", "returns", "the", "two", "proxy", "settings", ";", "http", "and", "https", "." ]

[ "func", "(", "c", "*", "Config", ")", "LogFwdSyslog", "(", ")", "(", "*", "syslog", ".", "RawConfig", ",", "bool", ")", "{", "partial", ":=", "false", "\n", "var", "lfCfg", "syslog", ".", "RawConfig", "\n\n", "if", "s", ",", "ok", ":=", "c", ".", "defined", "[", "LogForwardEnabled", "]", ";", "ok", "{", "partial", "=", "true", "\n", "lfCfg", ".", "Enabled", "=", "s", ".", "(", "bool", ")", "\n", "}", "\n\n", "if", "s", ",", "ok", ":=", "c", ".", "defined", "[", "LogFwdSyslogHost", "]", ";", "ok", "&&", "s", "!=", "\"", "\"", "{", "partial", "=", "true", "\n", "lfCfg", ".", "Host", "=", "s", ".", "(", "string", ")", "\n", "}", "\n\n", "if", "s", ",", "ok", ":=", "c", ".", "defined", "[", "LogFwdSyslogCACert", "]", ";", "ok", "&&", "s", "!=", "\"", "\"", "{", "partial", "=", "true", "\n", "lfCfg", ".", "CACert", "=", "s", ".", "(", "string", ")", "\n", "}", "\n\n", "if", "s", ",", "ok", ":=", "c", ".", "defined", "[", "LogFwdSyslogClientCert", "]", ";", "ok", "&&", "s", "!=", "\"", "\"", "{", "partial", "=", "true", "\n", "lfCfg", ".", "ClientCert", "=", "s", ".", "(", "string", ")", "\n", "}", "\n\n", "if", "s", ",", "ok", ":=", "c", ".", "defined", "[", "LogFwdSyslogClientKey", "]", ";", "ok", "&&", "s", "!=", "\"", "\"", "{", "partial", "=", "true", "\n", "lfCfg", ".", "ClientKey", "=", "s", ".", "(", "string", ")", "\n", "}", "\n\n", "if", "!", "partial", "{", "return", "nil", ",", "false", "\n", "}", "\n", "return", "&", "lfCfg", ",", "true", "\n", "}" ]

[ "LogFwdSyslog", "returns", "the", "syslog", "forwarding", "config", "." ]

[ "func", "(", "c", "*", "Config", ")", "AgentVersion", "(", ")", "(", "version", ".", "Number", ",", "bool", ")", "{", "if", "v", ",", "ok", ":=", "c", ".", "defined", "[", "AgentVersionKey", "]", ".", "(", "string", ")", ";", "ok", "{", "n", ",", "err", ":=", "version", ".", "Parse", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// We should have checked it earlier.", "\n", "}", "\n", "return", "n", ",", "true", "\n", "}", "\n", "return", "version", ".", "Zero", ",", "false", "\n", "}" ]

[ "AgentVersion", "returns", "the", "proposed", "version", "number", "for", "the", "agent", "tools", "and", "whether", "it", "has", "been", "set", ".", "Once", "an", "environment", "is", "bootstrapped", "this", "must", "always", "be", "valid", "." ]

[ "func", "(", "c", "*", "Config", ")", "AgentMetadataURL", "(", ")", "(", "string", ",", "bool", ")", "{", "if", "url", ",", "ok", ":=", "c", ".", "defined", "[", "AgentMetadataURLKey", "]", ";", "ok", "&&", "url", "!=", "\"", "\"", "{", "return", "url", ".", "(", "string", ")", ",", "true", "\n", "}", "\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "AgentMetadataURL", "returns", "the", "URL", "that", "locates", "the", "agent", "tarballs", "and", "metadata", "and", "whether", "it", "has", "been", "set", "." ]

[ "func", "(", "c", "*", "Config", ")", "ImageMetadataURL", "(", ")", "(", "string", ",", "bool", ")", "{", "if", "url", ",", "ok", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ";", "ok", "&&", "url", "!=", "\"", "\"", "{", "return", "url", ".", "(", "string", ")", ",", "true", "\n", "}", "\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "ImageMetadataURL", "returns", "the", "URL", "at", "which", "the", "metadata", "used", "to", "locate", "image", "ids", "is", "located", "and", "whether", "it", "has", "been", "set", "." ]

[ "func", "(", "c", "*", "Config", ")", "ContainerImageMetadataURL", "(", ")", "(", "string", ",", "bool", ")", "{", "if", "url", ",", "ok", ":=", "c", ".", "defined", "[", "ContainerImageMetadataURLKey", "]", ";", "ok", "&&", "url", "!=", "\"", "\"", "{", "return", "url", ".", "(", "string", ")", ",", "true", "\n", "}", "\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "ContainerImageMetadataURL", "returns", "the", "URL", "at", "which", "the", "metadata", "used", "to", "locate", "container", "OS", "image", "ids", "is", "located", "and", "whether", "it", "has", "been", "set", "." ]

[ "func", "(", "c", "*", "Config", ")", "Development", "(", ")", "bool", "{", "value", ",", "_", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ".", "(", "bool", ")", "\n", "return", "value", "\n", "}" ]

[ "Development", "returns", "whether", "the", "environment", "is", "in", "development", "mode", "." ]

[ "func", "(", "c", "*", "Config", ")", "EnableOSRefreshUpdate", "(", ")", "bool", "{", "if", "val", ",", "ok", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ".", "(", "bool", ")", ";", "!", "ok", "{", "return", "true", "\n", "}", "else", "{", "return", "val", "\n", "}", "\n", "}" ]

[ "EnableOSRefreshUpdate", "returns", "whether", "or", "not", "newly", "provisioned", "instances", "should", "run", "their", "respective", "OS", "s", "update", "capability", "." ]

[ "func", "(", "c", "*", "Config", ")", "EnableOSUpgrade", "(", ")", "bool", "{", "if", "val", ",", "ok", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ".", "(", "bool", ")", ";", "!", "ok", "{", "return", "true", "\n", "}", "else", "{", "return", "val", "\n", "}", "\n", "}" ]

[ "EnableOSUpgrade", "returns", "whether", "or", "not", "newly", "provisioned", "instances", "should", "run", "their", "respective", "OS", "s", "upgrade", "capability", "." ]

[ "func", "(", "c", "*", "Config", ")", "AutomaticallyRetryHooks", "(", ")", "bool", "{", "if", "val", ",", "ok", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ".", "(", "bool", ")", ";", "!", "ok", "{", "return", "true", "\n", "}", "else", "{", "return", "val", "\n", "}", "\n", "}" ]

[ "AutomaticallyRetryHooks", "returns", "whether", "we", "should", "automatically", "retry", "hooks", ".", "By", "default", "this", "should", "be", "true", "." ]

[ "func", "(", "c", "*", "Config", ")", "TransmitVendorMetrics", "(", ")", "bool", "{", "if", "val", ",", "ok", ":=", "c", ".", "defined", "[", "TransmitVendorMetricsKey", "]", ".", "(", "bool", ")", ";", "!", "ok", "{", "return", "true", "\n", "}", "else", "{", "return", "val", "\n", "}", "\n", "}" ]

[ "TransmitVendorMetrics", "returns", "whether", "the", "controller", "sends", "charm", "-", "collected", "metrics", "in", "this", "model", "for", "anonymized", "aggregate", "analytics", ".", "By", "default", "this", "should", "be", "true", "." ]

[ "func", "(", "c", "*", "Config", ")", "ProvisionerHarvestMode", "(", ")", "HarvestMode", "{", "if", "v", ",", "ok", ":=", "c", ".", "defined", "[", "ProvisionerHarvestModeKey", "]", ".", "(", "string", ")", ";", "ok", "{", "if", "method", ",", "err", ":=", "ParseHarvestMode", "(", "v", ")", ";", "err", "!=", "nil", "{", "// This setting should have already been validated. Don't", "// burden the caller with handling any errors.", "panic", "(", "err", ")", "\n", "}", "else", "{", "return", "method", "\n", "}", "\n", "}", "else", "{", "return", "HarvestDestroyed", "\n", "}", "\n", "}" ]

[ "ProvisionerHarvestMode", "reports", "the", "harvesting", "methodology", "the", "provisioner", "should", "take", "." ]

[ "func", "(", "c", "*", "Config", ")", "ImageStream", "(", ")", "string", "{", "v", ",", "_", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ".", "(", "string", ")", "\n", "if", "v", "!=", "\"", "\"", "{", "return", "v", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "ImageStream", "returns", "the", "simplestreams", "stream", "used", "to", "identify", "which", "image", "ids", "to", "search", "when", "starting", "an", "instance", "." ]

[ "func", "(", "c", "*", "Config", ")", "AgentStream", "(", ")", "string", "{", "v", ",", "_", ":=", "c", ".", "defined", "[", "AgentStreamKey", "]", ".", "(", "string", ")", "\n", "if", "v", "!=", "\"", "\"", "{", "return", "v", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "AgentStream", "returns", "the", "simplestreams", "stream", "used", "to", "identify", "which", "tools", "to", "use", "when", "when", "bootstrapping", "or", "upgrading", "an", "environment", "." ]

[ "func", "(", "c", "*", "Config", ")", "ContainerImageStream", "(", ")", "string", "{", "v", ",", "_", ":=", "c", ".", "defined", "[", "ContainerImageStreamKey", "]", ".", "(", "string", ")", "\n", "if", "v", "!=", "\"", "\"", "{", "return", "v", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "ContainerImageStream", "returns", "the", "simplestreams", "stream", "used", "to", "identify", "which", "image", "ids", "to", "search", "when", "starting", "a", "container", "." ]

[ "func", "(", "c", "*", "Config", ")", "DisableNetworkManagement", "(", ")", "(", "bool", ",", "bool", ")", "{", "v", ",", "ok", ":=", "c", ".", "defined", "[", "\"", "\"", "]", ".", "(", "bool", ")", "\n", "return", "v", ",", "ok", "\n", "}" ]

[ "DisableNetworkManagement", "reports", "whether", "Juju", "is", "allowed", "to", "configure", "and", "manage", "networking", "inside", "the", "environment", "." ]

[ "func", "(", "c", "*", "Config", ")", "IgnoreMachineAddresses", "(", ")", "(", "bool", ",", "bool", ")", "{", "v", ",", "ok", ":=", "c", ".", "defined", "[", "IgnoreMachineAddresses", "]", ".", "(", "bool", ")", "\n", "return", "v", ",", "ok", "\n", "}" ]

[ "IgnoreMachineAddresses", "reports", "whether", "Juju", "will", "discover", "and", "store", "machine", "addresses", "on", "startup", "." ]

[ "func", "(", "c", "*", "Config", ")", "StorageDefaultBlockSource", "(", ")", "(", "string", ",", "bool", ")", "{", "bs", ":=", "c", ".", "asString", "(", "StorageDefaultBlockSourceKey", ")", "\n", "return", "bs", ",", "bs", "!=", "\"", "\"", "\n", "}" ]

[ "StorageDefaultBlockSource", "returns", "the", "default", "block", "storage", "source", "for", "the", "environment", "." ]

[ "func", "(", "c", "*", "Config", ")", "StorageDefaultFilesystemSource", "(", ")", "(", "string", ",", "bool", ")", "{", "bs", ":=", "c", ".", "asString", "(", "StorageDefaultFilesystemSourceKey", ")", "\n", "return", "bs", ",", "bs", "!=", "\"", "\"", "\n", "}" ]

[ "StorageDefaultFilesystemSource", "returns", "the", "default", "filesystem", "storage", "source", "for", "the", "environment", "." ]

[ "func", "(", "c", "*", "Config", ")", "ResourceTags", "(", ")", "(", "map", "[", "string", "]", "string", ",", "bool", ")", "{", "tags", ",", "err", ":=", "c", ".", "resourceTags", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// should be prevented by Validate", "\n", "}", "\n", "return", "tags", ",", "tags", "!=", "nil", "\n", "}" ]

[ "ResourceTags", "returns", "a", "set", "of", "tags", "to", "set", "on", "environment", "resources", "that", "Juju", "creates", "and", "manages", "if", "the", "provider", "supports", "them", ".", "These", "tags", "have", "no", "special", "meaning", "to", "Juju", "but", "may", "be", "used", "for", "existing", "chargeback", "accounting", "schemes", "or", "other", "identification", "purposes", "." ]

[ "func", "(", "c", "*", "Config", ")", "MaxStatusHistorySizeMB", "(", ")", "uint", "{", "// Value has already been validated.", "val", ",", "_", ":=", "utils", ".", "ParseSize", "(", "c", ".", "mustString", "(", "MaxStatusHistorySize", ")", ")", "\n", "return", "uint", "(", "val", ")", "\n", "}" ]

[ "MaxStatusHistorySizeMB", "is", "the", "maximum", "size", "in", "MiB", "which", "the", "status", "history", "collection", "can", "grow", "to", "before", "being", "pruned", "." ]

[ "func", "(", "c", "*", "Config", ")", "UpdateStatusHookInterval", "(", ")", "time", ".", "Duration", "{", "// TODO(wallyworld) - remove this work around when possible as", "// we already have a defaulting mechanism for config.", "// It's only here to guard against using Juju clients >= 2.2", "// with Juju controllers running 2.1.x", "raw", ":=", "c", ".", "asString", "(", "UpdateStatusHookInterval", ")", "\n", "if", "raw", "==", "\"", "\"", "{", "raw", "=", "DefaultUpdateStatusHookInterval", "\n", "}", "\n", "// Value has already been validated.", "val", ",", "_", ":=", "time", ".", "ParseDuration", "(", "raw", ")", "\n", "return", "val", "\n", "}" ]

[ "UpdateStatusHookInterval", "is", "how", "often", "to", "run", "the", "charm", "update", "-", "status", "hook", "." ]

[ "func", "(", "c", "*", "Config", ")", "EgressSubnets", "(", ")", "[", "]", "string", "{", "raw", ":=", "c", ".", "asString", "(", "EgressSubnets", ")", "\n", "if", "raw", "==", "\"", "\"", "{", "return", "[", "]", "string", "{", "}", "\n", "}", "\n", "// Value has already been validated.", "rawAddr", ":=", "strings", ".", "Split", "(", "raw", ",", "\"", "\"", ")", "\n", "result", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "rawAddr", ")", ")", "\n", "for", "i", ",", "addr", ":=", "range", "rawAddr", "{", "result", "[", "i", "]", "=", "strings", ".", "TrimSpace", "(", "addr", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "EgressSubnets", "are", "the", "source", "addresses", "from", "which", "traffic", "from", "this", "model", "originates", "if", "the", "model", "is", "deployed", "such", "that", "NAT", "or", "similar", "is", "in", "use", "." ]

[ "func", "(", "c", "*", "Config", ")", "FanConfig", "(", ")", "(", "network", ".", "FanConfig", ",", "error", ")", "{", "// At this point we are sure that the line is valid.", "return", "network", ".", "ParseFanConfig", "(", "c", ".", "asString", "(", "FanConfig", ")", ")", "\n", "}" ]

[ "FanConfig", "is", "the", "configuration", "of", "FAN", "network", "running", "in", "the", "model", "." ]

[ "func", "(", "c", "*", "Config", ")", "CloudInitUserData", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "raw", ":=", "c", ".", "asString", "(", "CloudInitUserDataKey", ")", "\n", "if", "raw", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "// The raw data has already passed Validate()", "conformingUserDataMap", ",", "_", ":=", "ensureStringMaps", "(", "raw", ")", "\n", "return", "conformingUserDataMap", "\n", "}" ]

[ "CloudInitUserData", "returns", "a", "copy", "of", "the", "raw", "user", "data", "attributes", "that", "were", "specified", "by", "the", "user", "." ]

[ "func", "(", "c", "*", "Config", ")", "UnknownAttrs", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "newAttrs", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "k", ",", "v", ":=", "range", "c", ".", "unknown", "{", "newAttrs", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "newAttrs", "\n", "}" ]

[ "UnknownAttrs", "returns", "a", "copy", "of", "the", "raw", "configuration", "attributes", "that", "are", "supposedly", "specific", "to", "the", "environment", "type", ".", "They", "could", "also", "be", "wrong", "attributes", "though", ".", "Only", "the", "specific", "environment", "implementation", "can", "tell", "." ]

[ "func", "(", "c", "*", "Config", ")", "AllAttrs", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "allAttrs", ":=", "c", ".", "UnknownAttrs", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "c", ".", "defined", "{", "allAttrs", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "allAttrs", "\n", "}" ]

[ "AllAttrs", "returns", "a", "copy", "of", "the", "raw", "configuration", "attributes", "." ]

[ "func", "(", "c", "*", "Config", ")", "Remove", "(", "attrs", "[", "]", "string", ")", "(", "*", "Config", ",", "error", ")", "{", "defined", ":=", "c", ".", "AllAttrs", "(", ")", "\n", "for", "_", ",", "k", ":=", "range", "attrs", "{", "delete", "(", "defined", ",", "k", ")", "\n", "}", "\n", "return", "New", "(", "NoDefaults", ",", "defined", ")", "\n", "}" ]

[ "Remove", "returns", "a", "new", "configuration", "that", "has", "the", "attributes", "of", "c", "minus", "attrs", "." ]

[ "func", "(", "c", "*", "Config", ")", "Apply", "(", "attrs", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "*", "Config", ",", "error", ")", "{", "defined", ":=", "c", ".", "AllAttrs", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "attrs", "{", "defined", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "New", "(", "NoDefaults", ",", "defined", ")", "\n", "}" ]

[ "Apply", "returns", "a", "new", "configuration", "that", "has", "the", "attributes", "of", "c", "plus", "attrs", "." ]

[ "func", "allDefaults", "(", ")", "schema", ".", "Defaults", "{", "d", ":=", "schema", ".", "Defaults", "{", "}", "\n", "configDefaults", ":=", "ConfigDefaults", "(", ")", "\n", "for", "attr", ",", "val", ":=", "range", "configDefaults", "{", "d", "[", "attr", "]", "=", "val", "\n", "}", "\n", "for", "attr", ",", "val", ":=", "range", "alwaysOptional", "{", "if", "_", ",", "ok", ":=", "d", "[", "attr", "]", ";", "!", "ok", "{", "d", "[", "attr", "]", "=", "val", "\n", "}", "\n", "}", "\n", "return", "d", "\n", "}" ]

[ "allDefaults", "returns", "a", "schema", ".", "Defaults", "that", "contains", "defaults", "to", "be", "used", "when", "creating", "a", "new", "config", "with", "UseDefaults", "." ]

[ "func", "SpecializeCharmRepo", "(", "repo", "charmrepo", ".", "Interface", ",", "cfg", "*", "Config", ")", "charmrepo", ".", "Interface", "{", "type", "specializer", "interface", "{", "WithTestMode", "(", ")", "charmrepo", ".", "Interface", "\n", "}", "\n", "if", "store", ",", "ok", ":=", "repo", ".", "(", "specializer", ")", ";", "ok", "{", "if", "cfg", ".", "TestMode", "(", ")", "{", "return", "store", ".", "WithTestMode", "(", ")", "\n", "}", "\n", "}", "\n", "return", "repo", "\n", "}" ]

[ "SpecializeCharmRepo", "customizes", "a", "repository", "for", "a", "given", "configuration", ".", "It", "returns", "a", "charm", "repository", "with", "test", "mode", "enabled", "if", "applicable", "." ]

[ "func", "ProxyConfigMap", "(", "proxySettings", "proxy", ".", "Settings", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "settings", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "HTTPProxyKey", ",", "proxySettings", ".", "Http", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "HTTPSProxyKey", ",", "proxySettings", ".", "Https", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "FTPProxyKey", ",", "proxySettings", ".", "Ftp", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "NoProxyKey", ",", "proxySettings", ".", "NoProxy", ")", "\n", "return", "settings", "\n", "}" ]

[ "ProxyConfigMap", "returns", "a", "map", "suitable", "to", "be", "applied", "to", "a", "Config", "to", "update", "proxy", "settings", "." ]

[ "func", "AptProxyConfigMap", "(", "proxySettings", "proxy", ".", "Settings", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "settings", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "AptHTTPProxyKey", ",", "proxySettings", ".", "Http", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "AptHTTPSProxyKey", ",", "proxySettings", ".", "Https", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "AptFTPProxyKey", ",", "proxySettings", ".", "Ftp", ")", "\n", "addIfNotEmpty", "(", "settings", ",", "AptNoProxyKey", ",", "proxySettings", ".", "NoProxy", ")", "\n", "return", "settings", "\n", "}" ]

[ "AptProxyConfigMap", "returns", "a", "map", "suitable", "to", "be", "applied", "to", "a", "Config", "to", "update", "proxy", "settings", "." ]

[ "func", "Schema", "(", "extra", "environschema", ".", "Fields", ")", "(", "environschema", ".", "Fields", ",", "error", ")", "{", "fields", ":=", "make", "(", "environschema", ".", "Fields", ")", "\n", "for", "name", ",", "field", ":=", "range", "configSchema", "{", "if", "controller", ".", "ControllerOnlyAttribute", "(", "name", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "fields", "[", "name", "]", "=", "field", "\n", "}", "\n", "for", "name", ",", "field", ":=", "range", "extra", "{", "if", "controller", ".", "ControllerOnlyAttribute", "(", "name", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "fields", "[", "name", "]", ";", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "fields", "[", "name", "]", "=", "field", "\n", "}", "\n", "return", "fields", ",", "nil", "\n", "}" ]

[ "Schema", "returns", "a", "configuration", "schema", "that", "includes", "both", "the", "given", "extra", "fields", "and", "all", "the", "fields", "defined", "in", "this", "package", ".", "It", "returns", "an", "error", "if", "extra", "defines", "any", "fields", "defined", "in", "this", "package", "." ]

[ "func", "SyncTools", "(", "syncContext", "*", "SyncContext", ")", "error", "{", "sourceDataSource", ",", "err", ":=", "selectSourceDatasource", "(", "syncContext", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "if", "syncContext", ".", "MajorVersion", "==", "0", "&&", "syncContext", ".", "MinorVersion", "==", "0", "{", "syncContext", ".", "MajorVersion", "=", "jujuversion", ".", "Current", ".", "Major", "\n", "syncContext", ".", "MinorVersion", "=", "-", "1", "\n", "if", "!", "syncContext", ".", "AllVersions", "{", "syncContext", ".", "MinorVersion", "=", "jujuversion", ".", "Current", ".", "Minor", "\n", "}", "\n", "}", "\n\n", "toolsDir", ":=", "syncContext", ".", "Stream", "\n", "// If no stream has been specified, assume \"released\" for non-devel versions of Juju.", "if", "syncContext", ".", "Stream", "==", "\"", "\"", "{", "// We now store the tools in a directory named after their stream, but the", "// legacy behaviour is to store all tools in a single \"releases\" directory.", "toolsDir", "=", "envtools", ".", "ReleasedStream", "\n", "// Always use the primary stream here - the user can specify", "// to override that decision.", "syncContext", ".", "Stream", "=", "envtools", ".", "PreferredStreams", "(", "&", "jujuversion", ".", "Current", ",", "false", ",", "\"", "\"", ")", "[", "0", "]", "\n", "}", "\n", "// For backwards compatibility with cloud storage, if there are no tools in the specified stream,", "// double check the release stream.", "// TODO - remove this when we no longer need to support cloud storage upgrades.", "streams", ":=", "[", "]", "string", "{", "syncContext", ".", "Stream", ",", "envtools", ".", "ReleasedStream", "}", "\n", "sourceTools", ",", "err", ":=", "envtools", ".", "FindToolsForCloud", "(", "[", "]", "simplestreams", ".", "DataSource", "{", "sourceDataSource", "}", ",", "simplestreams", ".", "CloudSpec", "{", "}", ",", "streams", ",", "syncContext", ".", "MajorVersion", ",", "syncContext", ".", "MinorVersion", ",", "coretools", ".", "Filter", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "len", "(", "sourceTools", ")", ")", "\n", "if", "!", "syncContext", ".", "AllVersions", "{", "var", "latest", "version", ".", "Number", "\n", "latest", ",", "sourceTools", "=", "sourceTools", ".", "Newest", "(", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "len", "(", "sourceTools", ")", ",", "latest", ")", "\n", "}", "\n", "for", "_", ",", "tool", ":=", "range", "sourceTools", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tool", ")", "\n", "}", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "targetTools", ",", "err", ":=", "syncContext", ".", "TargetToolsFinder", ".", "FindTools", "(", "syncContext", ".", "MajorVersion", ",", "syncContext", ".", "Stream", ")", "\n", "switch", "err", "{", "case", "nil", ",", "coretools", ".", "ErrNoMatches", ",", "envtools", ".", "ErrNoTools", ":", "default", ":", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "tool", ":=", "range", "targetTools", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tool", ")", "\n", "}", "\n\n", "missing", ":=", "sourceTools", ".", "Exclude", "(", "targetTools", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "len", "(", "targetTools", ")", ",", "len", "(", "missing", ")", ")", "\n", "if", "syncContext", ".", "DryRun", "{", "for", "_", ",", "tools", ":=", "range", "missing", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "tools", ".", "Version", ",", "tools", ".", "URL", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "err", "=", "copyTools", "(", "toolsDir", ",", "syncContext", ".", "Stream", ",", "missing", ",", "syncContext", ".", "TargetToolsUploader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "len", "(", "missing", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "SyncTools", "copies", "the", "Juju", "tools", "tarball", "from", "the", "official", "bucket", "or", "a", "specified", "source", "directory", "into", "the", "user", "s", "environment", "." ]