Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "DeserializeFingerprint", "(", "fpSum", "[", "]", "byte", ")", "(", "resource", ".", "Fingerprint", ",", "error", ")", "{", "var", "fp", "resource", ".", "Fingerprint", "\n", "if", "len", "(", "fpSum", ")", "!=", "0", "{", "var", "err", "error", "\n", "fp", ",", "err", "=", "resource", ".", "NewFingerprint", "(", "fpSum", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fp", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "fp", ",", "nil", "\n", "}" ]

[ "DeserializeFingerprint", "converts", "the", "serialized", "fingerprint", "back", "into", "a", "Fingerprint", ".", "zero", "values", "are", "treated", "appropriately", "." ]

[ "func", "(", "m", "leadershipChecker", ")", "LeadershipCheck", "(", "applicationName", ",", "unitName", "string", ")", "leadership", ".", "Token", "{", "token", ":=", "m", ".", "checker", ".", "Token", "(", "applicationName", ",", "unitName", ")", "\n", "return", "leadershipToken", "{", "applicationName", ":", "applicationName", ",", "unitName", ":", "unitName", ",", "token", ":", "token", ",", "}", "\n", "}" ]

[ "LeadershipCheck", "is", "part", "of", "the", "leadership", ".", "Checker", "interface", "." ]

[ "func", "(", "t", "leadershipToken", ")", "Check", "(", "attempt", "int", ",", "out", "interface", "{", "}", ")", "error", "{", "err", ":=", "t", ".", "token", ".", "Check", "(", "attempt", ",", "out", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "lease", ".", "ErrNotHeld", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "t", ".", "unitName", ",", "t", ".", "applicationName", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "Check", "is", "part", "of", "the", "leadership", ".", "Token", "interface", "." ]

[ "func", "formatListSummary", "(", "writer", "io", ".", "Writer", ",", "value", "interface", "{", "}", ")", "error", "{", "offers", ",", "ok", ":=", "value", ".", "(", "offeredApplications", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "offers", ",", "value", ")", "\n", "}", "\n", "return", "formatListEndpointsSummary", "(", "writer", ",", "offers", ")", "\n", "}" ]

[ "formatListSummary", "returns", "a", "tabular", "summary", "of", "remote", "application", "offers", "or", "errors", "out", "if", "parameter", "is", "not", "of", "expected", "type", "." ]

[ "func", "formatListEndpointsSummary", "(", "writer", "io", ".", "Writer", ",", "offers", "offeredApplications", ")", "error", "{", "tw", ":=", "output", ".", "TabWriter", "(", "writer", ")", "\n", "w", ":=", "output", ".", "Wrapper", "{", "tw", "}", "\n\n", "// Sort offers by source then application name.", "allOffers", ":=", "offerItems", "{", "}", "\n", "for", "_", ",", "offer", ":=", "range", "offers", "{", "allOffers", "=", "append", "(", "allOffers", ",", "offer", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "allOffers", ")", "\n\n", "w", ".", "Println", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "for", "_", ",", "offer", ":=", "range", "allOffers", "{", "// Sort endpoints alphabetically.", "endpoints", ":=", "[", "]", "string", "{", "}", "\n", "for", "endpoint", ":=", "range", "offer", ".", "Endpoints", "{", "endpoints", "=", "append", "(", "endpoints", ",", "endpoint", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "endpoints", ")", "\n\n", "for", "i", ",", "endpointName", ":=", "range", "endpoints", "{", "endpoint", ":=", "offer", ".", "Endpoints", "[", "endpointName", "]", "\n", "if", "i", "==", "0", "{", "// As there is some information about offer and its endpoints,", "// only display offer information once when the first endpoint is displayed.", "totalConnectedCount", ":=", "len", "(", "offer", ".", "Connections", ")", "\n", "activeConnectedCount", ":=", "0", "\n", "for", "_", ",", "conn", ":=", "range", "offer", ".", "Connections", "{", "if", "conn", ".", "Status", ".", "Current", "==", "relation", ".", "Joined", ".", "String", "(", ")", "{", "activeConnectedCount", "++", "\n", "}", "\n", "}", "\n", "w", ".", "Println", "(", "offer", ".", "OfferName", ",", "offer", ".", "ApplicationName", ",", "offer", ".", "CharmURL", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "activeConnectedCount", ",", "totalConnectedCount", ")", ",", "offer", ".", "Source", ",", "offer", ".", "OfferURL", ",", "endpointName", ",", "endpoint", ".", "Interface", ",", "endpoint", ".", "Role", ")", "\n", "continue", "\n", "}", "\n", "// Subsequent lines only need to display endpoint information.", "// This will display less noise.", "w", ".", "Println", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "endpointName", ",", "endpoint", ".", "Interface", ",", "endpoint", ".", "Role", ")", "\n", "}", "\n", "}", "\n", "tw", ".", "Flush", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "formatListEndpointsSummary", "returns", "a", "tabular", "summary", "of", "listed", "applications", "endpoints", "." ]

[ "func", "formatListEndpointsTabular", "(", "writer", "io", ".", "Writer", ",", "offers", "offeredApplications", ")", "error", "{", "tw", ":=", "output", ".", "TabWriter", "(", "writer", ")", "\n", "w", ":=", "output", ".", "Wrapper", "{", "tw", "}", "\n\n", "// Sort offers by source then application name.", "allOffers", ":=", "offerItems", "{", "}", "\n", "for", "_", ",", "offer", ":=", "range", "offers", "{", "allOffers", "=", "append", "(", "allOffers", ",", "offer", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "allOffers", ")", "\n\n", "w", ".", "Println", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "for", "_", ",", "offer", ":=", "range", "allOffers", "{", "// Sort endpoints alphabetically.", "endpoints", ":=", "[", "]", "string", "{", "}", "\n", "for", "endpoint", ":=", "range", "offer", ".", "Endpoints", "{", "endpoints", "=", "append", "(", "endpoints", ",", "endpoint", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "endpoints", ")", "\n\n", "// Sort connections by relation id and username.", "sort", ".", "Sort", "(", "byUserRelationId", "(", "offer", ".", "Connections", ")", ")", "\n\n", "// If there are no connections, print am empty row.", "if", "len", "(", "offer", ".", "Connections", ")", "==", "0", "{", "w", ".", "Println", "(", "offer", ".", "OfferName", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "for", "i", ",", "conn", ":=", "range", "offer", ".", "Connections", "{", "if", "i", "==", "0", "{", "w", ".", "Print", "(", "offer", ".", "OfferName", ")", "\n", "}", "else", "{", "w", ".", "Print", "(", "\"", "\"", ")", "\n", "}", "\n", "endpoints", ":=", "make", "(", "map", "[", "string", "]", "RemoteEndpoint", ")", "\n", "for", "alias", ",", "ep", ":=", "range", "offer", ".", "Endpoints", "{", "aliasedEp", ":=", "ep", "\n", "aliasedEp", ".", "Name", "=", "alias", "\n", "endpoints", "[", "ep", ".", "Name", "]", "=", "ep", "\n", "}", "\n", "connEp", ":=", "endpoints", "[", "conn", ".", "Endpoint", "]", "\n", "w", ".", "Print", "(", "conn", ".", "Username", ",", "conn", ".", "RelationId", ")", "\n", "w", ".", "PrintColor", "(", "RelationStatusColor", "(", "relation", ".", "Status", "(", "conn", ".", "Status", ".", "Current", ")", ")", ",", "conn", ".", "Status", ".", "Current", ")", "\n", "w", ".", "Println", "(", "connEp", ".", "Name", ",", "connEp", ".", "Interface", ",", "connEp", ".", "Role", ",", "strings", ".", "Join", "(", "conn", ".", "IngressSubnets", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n", "tw", ".", "Flush", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "formatListEndpointsTabular", "returns", "a", "tabular", "summary", "of", "listed", "applications", "endpoints", "." ]

[ "func", "RelationStatusColor", "(", "status", "relation", ".", "Status", ")", "*", "ansiterm", ".", "Context", "{", "switch", "status", "{", "case", "relation", ".", "Joined", ":", "return", "output", ".", "GoodHighlight", "\n", "case", "relation", ".", "Suspended", ":", "return", "output", ".", "WarningHighlight", "\n", "case", "relation", ".", "Broken", ",", "relation", ".", "Error", ":", "return", "output", ".", "ErrorHighlight", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RelationStatusColor", "returns", "a", "context", "used", "to", "print", "the", "status", "with", "the", "relevant", "color", "." ]

[ "func", "runCommand", "(", "cmd", "string", ",", "args", "...", "string", ")", "error", "{", "command", ":=", "exec", ".", "Command", "(", "cmd", ",", "args", "...", ")", "\n", "out", ",", "err", ":=", "command", ".", "CombinedOutput", "(", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "exec", ".", "ExitError", ")", ";", "ok", "&&", "len", "(", "out", ")", ">", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "cmd", ",", "strings", ".", "Replace", "(", "string", "(", "out", ")", ",", "\"", "\\n", "\"", ",", "\"", "\"", ",", "-", "1", ")", ",", ")", "\n", "}", "\n", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "cmd", ")", "\n", "}" ]

[ "runCommand", "execs", "the", "provided", "command", ".", "It", "exists", "here", "so", "it", "can", "be", "overridden", "in", "export_test", ".", "go" ]

[ "func", "ConfigureLXDProxies", "(", "proxies", "proxy", ".", "Settings", ")", "error", "{", "running", ",", "err", ":=", "IsRunningLocally", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "!", "running", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "svr", ",", "err", ":=", "NewLocalServer", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "errors", ".", "Trace", "(", "svr", ".", "UpdateServerConfig", "(", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "proxies", ".", "Http", ",", "\"", "\"", ":", "proxies", ".", "Https", ",", "\"", "\"", ":", "proxies", ".", "NoProxy", ",", "}", ")", ")", "\n", "}" ]

[ "ConfigureLXDProxies", "will", "try", "to", "set", "the", "lxc", "config", "core", ".", "proxy_http", "and", "core", ".", "proxy_https", "configuration", "values", "based", "on", "the", "current", "environment", ".", "If", "LXD", "is", "not", "installed", "we", "skip", "the", "configuration", "." ]

[ "func", "ensureDependencies", "(", "series", "string", ")", "error", "{", "if", "series", "==", "\"", "\"", "{", "return", "errors", ".", "NotSupportedf", "(", "`LXD containers on series \"precise\"`", ")", "\n", "}", "\n\n", "if", "lxdViaSnap", "(", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "pacman", ",", "err", ":=", "getPackageManager", "(", "series", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "pacconfer", ",", "err", ":=", "getPackagingConfigurer", "(", "series", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "pack", ":=", "range", "requiredPackages", "{", "pkg", ":=", "pack", "\n", "if", "config", ".", "SeriesRequiresCloudArchiveTools", "(", "series", ")", "&&", "pacconfer", ".", "IsCloudArchivePackage", "(", "pack", ")", "{", "pkg", "=", "strings", ".", "Join", "(", "pacconfer", ".", "ApplyCloudArchiveTarget", "(", "pack", ")", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "config", ".", "RequiresBackports", "(", "series", ",", "pack", ")", "{", "pkg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "series", ",", "pkg", ")", "\n", "}", "\n\n", "if", "err", ":=", "pacman", ".", "Install", "(", "pkg", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "ensureDependencies", "creates", "a", "set", "of", "install", "packages", "using", "apt", ".", "GetPreparePackages", "and", "runs", "each", "set", "of", "packages", "through", "apt", ".", "GetInstall", "." ]

[ "func", "getKnownV4IPsAndCIDRs", "(", "addrFunc", "func", "(", ")", "(", "[", "]", "net", ".", "Addr", ",", "error", ")", ")", "(", "[", "]", "net", ".", "IP", ",", "[", "]", "*", "net", ".", "IPNet", ",", "error", ")", "{", "addrs", ",", "err", ":=", "addrFunc", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "knownIPs", ":=", "[", "]", "net", ".", "IP", "{", "}", "\n", "seenIPs", ":=", "set", ".", "NewStrings", "(", ")", "\n", "knownCIDRs", ":=", "[", "]", "*", "net", ".", "IPNet", "{", "}", "\n", "seenCIDRs", ":=", "set", ".", "NewStrings", "(", ")", "\n", "for", "_", ",", "netAddr", ":=", "range", "addrs", "{", "ip", ",", "ipNet", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "netAddr", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "if", "ip", ".", "To4", "(", ")", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "!", "seenIPs", ".", "Contains", "(", "ip", ".", "String", "(", ")", ")", "{", "knownIPs", "=", "append", "(", "knownIPs", ",", "ip", ")", "\n", "seenIPs", ".", "Add", "(", "ip", ".", "String", "(", ")", ")", "\n", "}", "\n", "if", "!", "seenCIDRs", ".", "Contains", "(", "ipNet", ".", "String", "(", ")", ")", "{", "knownCIDRs", "=", "append", "(", "knownCIDRs", ",", "ipNet", ")", "\n", "seenCIDRs", ".", "Add", "(", "ipNet", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "knownIPs", ",", "knownCIDRs", ",", "nil", "\n", "}" ]

[ "getKnownV4IPsAndCIDRs", "iterates", "all", "of", "the", "known", "Addresses", "on", "this", "machine", "and", "groups", "them", "up", "into", "known", "CIDRs", "and", "IP", "addresses", "." ]

[ "func", "bridgeConfiguration", "(", "input", "string", ")", "(", "string", ",", "error", ")", "{", "values", ":=", "parseLXDBridgeConfigValues", "(", "input", ")", "\n", "ipAddr", ":=", "net", ".", "ParseIP", "(", "values", "[", "\"", "\"", "]", ")", "\n\n", "if", "ipAddr", "==", "nil", "||", "ipAddr", ".", "To4", "(", ")", "==", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "subnet", ",", "err", ":=", "findNextAvailableIPv4Subnet", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "subnet", ")", "\n", "return", "editLXDBridgeFile", "(", "input", ",", "subnet", ")", ",", "nil", "\n", "}", "\n", "return", "input", ",", "nil", "\n", "}" ]

[ "bridgeConfiguration", "ensures", "that", "input", "has", "a", "valid", "setting", "for", "LXD_IPV4_ADDR", "returning", "the", "existing", "input", "if", "is", "already", "set", "and", "allocating", "the", "next", "available", "subnet", "if", "it", "is", "not", "." ]

[ "func", "InstalledServiceName", "(", ")", "(", "string", ",", "error", ")", "{", "names", ",", "err", ":=", "service", ".", "ListServices", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Prefer the Snap service.", "svcName", ":=", "\"", "\"", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "if", "name", "==", "\"", "\"", "{", "return", "name", ",", "nil", "\n", "}", "\n", "if", "name", "==", "\"", "\"", "{", "svcName", "=", "name", "\n", "}", "\n", "}", "\n", "return", "svcName", ",", "nil", "\n", "}" ]

[ "InstalledServiceName", "returns", "the", "name", "of", "the", "running", "service", "for", "the", "LXD", "daemon", ".", "If", "LXD", "is", "not", "installed", "the", "return", "is", "an", "empty", "string", "." ]

[ "func", "(", "cfg", "*", "ControllerPodConfig", ")", "AgentConfig", "(", "tag", "names", ".", "Tag", ")", "(", "agent", ".", "ConfigSetterWriter", ",", "error", ")", "{", "var", "password", ",", "cacert", "string", "\n", "if", "cfg", ".", "Controller", "==", "nil", "{", "password", "=", "cfg", ".", "APIInfo", ".", "Password", "\n", "cacert", "=", "cfg", ".", "APIInfo", ".", "CACert", "\n", "}", "else", "{", "password", "=", "cfg", ".", "Controller", ".", "MongoInfo", ".", "Password", "\n", "cacert", "=", "cfg", ".", "Controller", ".", "MongoInfo", ".", "CACert", "\n", "}", "\n", "configParams", ":=", "agent", ".", "AgentConfigParams", "{", "Paths", ":", "agent", ".", "Paths", "{", "DataDir", ":", "cfg", ".", "DataDir", ",", "LogDir", ":", "cfg", ".", "LogDir", ",", "MetricsSpoolDir", ":", "cfg", ".", "MetricsSpoolDir", ",", "}", ",", "Jobs", ":", "cfg", ".", "Jobs", ",", "Tag", ":", "tag", ",", "UpgradedToVersion", ":", "cfg", ".", "JujuVersion", ",", "Password", ":", "password", ",", "Nonce", ":", "cfg", ".", "PodNonce", ",", "APIAddresses", ":", "cfg", ".", "APIHostAddrs", "(", ")", ",", "CACert", ":", "cacert", ",", "Values", ":", "cfg", ".", "AgentEnvironment", ",", "Controller", ":", "cfg", ".", "ControllerTag", ",", "Model", ":", "cfg", ".", "APIInfo", ".", "ModelTag", ",", "MongoVersion", ":", "jujudbVersion", ",", "MongoMemoryProfile", ":", "mongo", ".", "MemoryProfile", "(", "cfg", ".", "Controller", ".", "Config", ".", "MongoMemoryProfile", "(", ")", ")", ",", "}", "\n", "return", "agent", ".", "NewStateMachineConfig", "(", "configParams", ",", "cfg", ".", "Bootstrap", ".", "StateServingInfo", ")", "\n", "}" ]

[ "AgentConfig", "returns", "an", "agent", "config", "." ]

[ "func", "(", "cfg", "*", "ControllerPodConfig", ")", "APIHostAddrs", "(", ")", "[", "]", "string", "{", "var", "hosts", "[", "]", "string", "\n", "if", "cfg", ".", "Bootstrap", "!=", "nil", "{", "hosts", "=", "append", "(", "hosts", ",", "net", ".", "JoinHostPort", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "cfg", ".", "Bootstrap", ".", "StateServingInfo", ".", "APIPort", ")", ")", ",", ")", "\n", "}", "\n", "if", "cfg", ".", "APIInfo", "!=", "nil", "{", "hosts", "=", "append", "(", "hosts", ",", "cfg", ".", "APIInfo", ".", "Addrs", "...", ")", "\n", "}", "\n", "return", "hosts", "\n", "}" ]

[ "APIHostAddrs", "returns", "a", "list", "of", "api", "server", "addresses", "." ]

[ "func", "(", "cfg", "*", "ControllerPodConfig", ")", "VerifyConfig", "(", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ")", "\n", "if", "!", "names", ".", "IsValidMachine", "(", "cfg", ".", "MachineId", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "DataDir", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "LogDir", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "MetricsSpoolDir", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "cfg", ".", "Jobs", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "JujuVersion", "==", "version", ".", "Zero", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "APIInfo", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "APIInfo", ".", "ModelTag", ".", "Id", "(", ")", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "cfg", ".", "APIInfo", ".", "CACert", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "PodNonce", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "ControllerName", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "cfg", ".", "Controller", "!=", "nil", "{", "if", "err", ":=", "cfg", ".", "verifyControllerConfig", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "cfg", ".", "Bootstrap", "!=", "nil", "{", "if", "err", ":=", "cfg", ".", "verifyBootstrapConfig", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "else", "{", "if", "cfg", ".", "APIInfo", ".", "Tag", "!=", "names", ".", "NewMachineTag", "(", "cfg", ".", "MachineId", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "cfg", ".", "APIInfo", ".", "Addrs", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "VerifyConfig", "verifies", "that", "the", "ControllerPodConfig", "is", "valid", "." ]

[ "func", "(", "cfg", "*", "ControllerPodConfig", ")", "GetHostedModel", "(", ")", "(", "string", ",", "bool", ")", "{", "hasHostedModel", ":=", "len", "(", "cfg", ".", "Bootstrap", ".", "HostedModelConfig", ")", ">", "0", "\n", "if", "hasHostedModel", "{", "modelName", ":=", "cfg", ".", "Bootstrap", ".", "HostedModelConfig", "[", "config", ".", "NameKey", "]", ".", "(", "string", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "modelName", ")", "\n", "return", "modelName", ",", "true", "\n", "}", "\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "GetHostedModel", "checks", "if", "hosted", "model", "was", "requested", "to", "create", "." ]

[ "func", "(", "cfg", "*", "ControllerConfig", ")", "VerifyConfig", "(", ")", "error", "{", "if", "cfg", ".", "MongoInfo", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "cfg", ".", "MongoInfo", ".", "CACert", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "VerifyConfig", "verifies", "that", "the", "ControllerConfig", "is", "valid", "." ]

[ "func", "NewControllerPodConfig", "(", "controllerTag", "names", ".", "ControllerTag", ",", "podID", ",", "podNonce", ",", "controllerName", ",", "series", "string", ",", "apiInfo", "*", "api", ".", "Info", ",", ")", "(", "*", "ControllerPodConfig", ",", "error", ")", "{", "dataDir", ",", "err", ":=", "paths", ".", "DataDir", "(", "series", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "logDir", ",", "err", ":=", "paths", ".", "LogDir", "(", "series", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "metricsSpoolDir", ",", "err", ":=", "paths", ".", "MetricsSpoolDir", "(", "series", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "pcfg", ":=", "&", "ControllerPodConfig", "{", "// Fixed entries.", "DataDir", ":", "dataDir", ",", "LogDir", ":", "path", ".", "Join", "(", "logDir", ",", "\"", "\"", ")", ",", "MetricsSpoolDir", ":", "metricsSpoolDir", ",", "Tags", ":", "map", "[", "string", "]", "string", "{", "}", ",", "// Parameter entries.", "ControllerTag", ":", "controllerTag", ",", "MachineId", ":", "podID", ",", "PodNonce", ":", "podNonce", ",", "ControllerName", ":", "controllerName", ",", "APIInfo", ":", "apiInfo", ",", "}", "\n", "return", "pcfg", ",", "nil", "\n", "}" ]

[ "NewControllerPodConfig", "sets", "up", "a", "basic", "pod", "configuration", ".", "You", "ll", "still", "need", "to", "supply", "more", "information", "but", "this", "takes", "care", "of", "the", "fixed", "entries", "and", "the", "ones", "that", "are", "always", "needed", "." ]

[ "func", "NewBootstrapControllerPodConfig", "(", "config", "controller", ".", "Config", ",", "controllerName", ",", "series", "string", ",", ")", "(", "*", "ControllerPodConfig", ",", "error", ")", "{", "// For a bootstrap pod, the caller must provide the state.Info", "// and the api.Info. The machine id must *always* be \"0\".", "pcfg", ",", "err", ":=", "NewControllerPodConfig", "(", "names", ".", "NewControllerTag", "(", "config", ".", "ControllerUUID", "(", ")", ")", ",", "\"", "\"", ",", "agent", ".", "BootstrapNonce", ",", "controllerName", ",", "series", ",", "nil", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "pcfg", ".", "Controller", "=", "&", "ControllerConfig", "{", "}", "\n", "pcfg", ".", "Controller", ".", "Config", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "k", ",", "v", ":=", "range", "config", "{", "pcfg", ".", "Controller", ".", "Config", "[", "k", "]", "=", "v", "\n", "}", "\n", "// TODO(bootstrap): remove me.", "arch", ":=", "arch", ".", "AMD64", "\n", "var", "cores", "uint64", "=", "2", "\n", "var", "mem", "uint64", "=", "123", "\n", "var", "rootDisk", "uint64", "=", "123", "\n", "pcfg", ".", "Bootstrap", "=", "&", "BootstrapConfig", "{", "BootstrapConfig", ":", "instancecfg", ".", "BootstrapConfig", "{", "StateInitializationParams", ":", "instancecfg", ".", "StateInitializationParams", "{", "// TODO(bootstrap): remove me once agentbootstrap.initBootstrapMachine works for CAAS bootstrap in jujud.", "BootstrapMachineHardwareCharacteristics", ":", "&", "instance", ".", "HardwareCharacteristics", "{", "Arch", ":", "&", "arch", ",", "CpuCores", ":", "&", "cores", ",", "Mem", ":", "&", "mem", ",", "RootDisk", ":", "&", "rootDisk", ",", "}", ",", "BootstrapMachineInstanceId", ":", "\"", "\"", ",", "BootstrapMachineConstraints", ":", "constraints", ".", "Value", "{", "Mem", ":", "&", "mem", "}", ",", "}", ",", "}", ",", "}", "\n\n", "pcfg", ".", "Jobs", "=", "[", "]", "multiwatcher", ".", "MachineJob", "{", "multiwatcher", ".", "JobManageModel", ",", "multiwatcher", ".", "JobHostUnits", ",", "}", "\n", "return", "pcfg", ",", "nil", "\n", "}" ]

[ "NewBootstrapControllerPodConfig", "sets", "up", "a", "basic", "pod", "configuration", "for", "a", "bootstrap", "pod", ".", "You", "ll", "still", "need", "to", "supply", "more", "information", "but", "this", "takes", "care", "of", "the", "fixed", "entries", "and", "the", "ones", "that", "are", "always", "needed", "." ]

[ "func", "PopulateControllerPodConfig", "(", "pcfg", "*", "ControllerPodConfig", ",", "providerType", "string", ")", "error", "{", "if", "pcfg", ".", "AgentEnvironment", "==", "nil", "{", "pcfg", ".", "AgentEnvironment", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "pcfg", ".", "AgentEnvironment", "[", "agent", ".", "ProviderType", "]", "=", "providerType", "\n", "pcfg", ".", "AgentEnvironment", "[", "agent", ".", "AgentServiceName", "]", "=", "\"", "\"", "+", "names", ".", "NewMachineTag", "(", "pcfg", ".", "MachineId", ")", ".", "String", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "PopulateControllerPodConfig", "is", "called", "both", "from", "the", "FinishControllerPodConfig", "below", "which", "does", "have", "access", "to", "the", "environment", "config", "and", "from", "the", "container", "provisioners", "which", "don", "t", "have", "access", "to", "the", "environment", "config", ".", "Everything", "that", "is", "needed", "to", "provision", "a", "container", "needs", "to", "be", "returned", "to", "the", "provisioner", "in", "the", "ContainerConfig", "structure", ".", "Those", "values", "are", "then", "used", "to", "call", "this", "function", "." ]

[ "func", "PodLabels", "(", "modelUUID", ",", "controllerUUID", "string", ",", "tagger", "tags", ".", "ResourceTagger", ",", "jobs", "[", "]", "multiwatcher", ".", "MachineJob", ")", "map", "[", "string", "]", "string", "{", "podLabels", ":=", "tags", ".", "ResourceTags", "(", "names", ".", "NewModelTag", "(", "modelUUID", ")", ",", "names", ".", "NewControllerTag", "(", "controllerUUID", ")", ",", "tagger", ",", ")", "\n", "// always be a controller.", "podLabels", "[", "tags", ".", "JujuIsController", "]", "=", "\"", "\"", "\n", "return", "podLabels", "\n", "}" ]

[ "PodLabels", "returns", "the", "minimum", "set", "of", "tags", "that", "should", "be", "set", "on", "a", "pod", "if", "the", "provider", "supports", "them", "." ]

[ "func", "NewFacade", "(", "apiCaller", "base", ".", "APICaller", ")", "(", "Facade", ",", "error", ")", "{", "return", "resumer", ".", "NewAPI", "(", "apiCaller", ")", ",", "nil", "\n", "}" ]

[ "NewFacade", "returns", "a", "useful", "live", "implementation", "for", "ManifoldConfig", ".", "NewFacade", "." ]

[ "func", "(", "cfg", "Config", ")", "Validate", "(", ")", "error", "{", "if", "cfg", ".", "ModelUUID", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "FirewallerAPI", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "RemoteRelationsApi", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "Mode", "==", "config", ".", "FwGlobal", "&&", "cfg", ".", "EnvironFirewaller", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "EnvironInstances", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "NewCrossModelFacadeFunc", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "CredentialAPI", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "returns", "an", "error", "if", "cfg", "cannot", "drive", "a", "Worker", "." ]

[ "func", "NewFirewaller", "(", "cfg", "Config", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "clk", ":=", "cfg", ".", "Clock", "\n", "if", "clk", "==", "nil", "{", "clk", "=", "clock", ".", "WallClock", "\n", "}", "\n\n", "fw", ":=", "&", "Firewaller", "{", "firewallerApi", ":", "cfg", ".", "FirewallerAPI", ",", "remoteRelationsApi", ":", "cfg", ".", "RemoteRelationsApi", ",", "environFirewaller", ":", "cfg", ".", "EnvironFirewaller", ",", "environInstances", ":", "cfg", ".", "EnvironInstances", ",", "newRemoteFirewallerAPIFunc", ":", "cfg", ".", "NewCrossModelFacadeFunc", ",", "modelUUID", ":", "cfg", ".", "ModelUUID", ",", "machineds", ":", "make", "(", "map", "[", "names", ".", "MachineTag", "]", "*", "machineData", ")", ",", "unitsChange", ":", "make", "(", "chan", "*", "unitsChange", ")", ",", "unitds", ":", "make", "(", "map", "[", "names", ".", "UnitTag", "]", "*", "unitData", ")", ",", "applicationids", ":", "make", "(", "map", "[", "names", ".", "ApplicationTag", "]", "*", "applicationData", ")", ",", "exposedChange", ":", "make", "(", "chan", "*", "exposedChange", ")", ",", "relationIngress", ":", "make", "(", "map", "[", "names", ".", "RelationTag", "]", "*", "remoteRelationData", ")", ",", "localRelationsChange", ":", "make", "(", "chan", "*", "remoteRelationNetworkChange", ")", ",", "pollClock", ":", "clk", ",", "relationWorkerRunner", ":", "worker", ".", "NewRunner", "(", "worker", ".", "RunnerParams", "{", "Clock", ":", "clk", ",", "// One of the remote relation workers failing should not", "// prevent the others from running.", "IsFatal", ":", "func", "(", "error", ")", "bool", "{", "return", "false", "}", ",", "// For any failures, try again in 1 minute.", "RestartDelay", ":", "time", ".", "Minute", ",", "}", ")", ",", "cloudCallContext", ":", "common", ".", "NewCloudCallContext", "(", "cfg", ".", "CredentialAPI", ",", "nil", ")", ",", "}", "\n\n", "switch", "cfg", ".", "Mode", "{", "case", "config", ".", "FwInstance", ":", "case", "config", ".", "FwGlobal", ":", "fw", ".", "globalMode", "=", "true", "\n", "fw", ".", "globalIngressRuleRef", "=", "make", "(", "map", "[", "string", "]", "int", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "cfg", ".", "Mode", ")", "\n", "}", "\n\n", "err", ":=", "catacomb", ".", "Invoke", "(", "catacomb", ".", "Plan", "{", "Site", ":", "&", "fw", ".", "catacomb", ",", "Work", ":", "fw", ".", "loop", ",", "Init", ":", "[", "]", "worker", ".", "Worker", "{", "fw", ".", "relationWorkerRunner", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "fw", ",", "nil", "\n", "}" ]

[ "NewFirewaller", "returns", "a", "new", "Firewaller", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "startMachine", "(", "tag", "names", ".", "MachineTag", ")", "error", "{", "machined", ":=", "&", "machineData", "{", "fw", ":", "fw", ",", "tag", ":", "tag", ",", "unitds", ":", "make", "(", "map", "[", "names", ".", "UnitTag", "]", "*", "unitData", ")", ",", "ingressRules", ":", "make", "(", "[", "]", "network", ".", "IngressRule", ",", "0", ")", ",", "definedPorts", ":", "make", "(", "map", "[", "names", ".", "UnitTag", "]", "portRanges", ")", ",", "}", "\n", "m", ",", "err", ":=", "machined", ".", "machine", "(", ")", "\n", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tag", ")", "\n", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "manual", ",", "err", ":=", "m", ".", "IsManual", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "manual", "{", "// Don't track manual machines, we can't change their ports.", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tag", ")", "\n", "return", "nil", "\n", "}", "\n", "unitw", ",", "err", ":=", "m", ".", "WatchUnits", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// XXX(fwereade): this is the best of a bunch of bad options. We've started", "// the watch, so we're responsible for it; but we (probably?) need to do this", "// little dance below to update the machined data on the fw loop goroutine,", "// whence it's usually accessed, before we start the machined watchLoop", "// below. That catacomb *should* be the only one responsible -- and it *is*", "// responsible -- but having it in the main fw catacomb as well does no harm,", "// and greatly simplifies the code below (which would otherwise have to", "// manage unitw lifetime and errors manually).", "if", "err", ":=", "fw", ".", "catacomb", ".", "Add", "(", "unitw", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "select", "{", "case", "<-", "fw", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "fw", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "change", ",", "ok", ":=", "<-", "unitw", ".", "Changes", "(", ")", ":", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "fw", ".", "machineds", "[", "tag", "]", "=", "machined", "\n", "err", "=", "fw", ".", "unitsChanged", "(", "&", "unitsChange", "{", "machined", ",", "change", "}", ")", "\n", "if", "err", "!=", "nil", "{", "delete", "(", "fw", ".", "machineds", ",", "tag", ")", "\n", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "tag", ")", "\n", "}", "\n", "}", "\n\n", "err", "=", "catacomb", ".", "Invoke", "(", "catacomb", ".", "Plan", "{", "Site", ":", "&", "machined", ".", "catacomb", ",", "Work", ":", "func", "(", ")", "error", "{", "return", "machined", ".", "watchLoop", "(", "unitw", ")", "\n", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "delete", "(", "fw", ".", "machineds", ",", "tag", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// register the machined with the firewaller's catacomb.", "err", "=", "fw", ".", "catacomb", ".", "Add", "(", "machined", ")", "\n", "if", "err", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tag", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "startMachine", "creates", "a", "new", "data", "value", "for", "tracking", "details", "of", "the", "machine", "and", "starts", "watching", "the", "machine", "for", "units", "added", "or", "removed", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "startUnit", "(", "unit", "*", "firewaller", ".", "Unit", ",", "machineTag", "names", ".", "MachineTag", ")", "error", "{", "application", ",", "err", ":=", "unit", ".", "Application", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "applicationTag", ":=", "application", ".", "Tag", "(", ")", "\n", "unitTag", ":=", "unit", ".", "Tag", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "unitd", ":=", "&", "unitData", "{", "fw", ":", "fw", ",", "unit", ":", "unit", ",", "tag", ":", "unitTag", ",", "}", "\n", "fw", ".", "unitds", "[", "unitTag", "]", "=", "unitd", "\n\n", "unitd", ".", "machined", "=", "fw", ".", "machineds", "[", "machineTag", "]", "\n", "unitd", ".", "machined", ".", "unitds", "[", "unitTag", "]", "=", "unitd", "\n", "if", "fw", ".", "applicationids", "[", "applicationTag", "]", "==", "nil", "{", "err", ":=", "fw", ".", "startApplication", "(", "application", ")", "\n", "if", "err", "!=", "nil", "{", "delete", "(", "fw", ".", "unitds", ",", "unitTag", ")", "\n", "delete", "(", "unitd", ".", "machined", ".", "unitds", ",", "unitTag", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "unitd", ".", "applicationd", "=", "fw", ".", "applicationids", "[", "applicationTag", "]", "\n", "unitd", ".", "applicationd", ".", "unitds", "[", "unitTag", "]", "=", "unitd", "\n\n", "m", ",", "err", ":=", "unitd", ".", "machined", ".", "machine", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// check if the machine has ports open on any subnets", "subnetTags", ",", "err", ":=", "m", ".", "ActiveSubnets", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "machineTag", ")", "\n", "}", "\n", "for", "_", ",", "subnetTag", ":=", "range", "subnetTags", "{", "err", ":=", "fw", ".", "openedPortsChanged", "(", "machineTag", ",", "subnetTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "startUnit", "creates", "a", "new", "data", "value", "for", "tracking", "details", "of", "the", "unit", "The", "provided", "machineTag", "must", "be", "the", "tag", "for", "the", "machine", "the", "unit", "was", "last", "observed", "to", "be", "assigned", "to", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "startApplication", "(", "app", "*", "firewaller", ".", "Application", ")", "error", "{", "exposed", ",", "err", ":=", "app", ".", "IsExposed", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "applicationd", ":=", "&", "applicationData", "{", "fw", ":", "fw", ",", "application", ":", "app", ",", "exposed", ":", "exposed", ",", "unitds", ":", "make", "(", "map", "[", "names", ".", "UnitTag", "]", "*", "unitData", ")", ",", "}", "\n", "fw", ".", "applicationids", "[", "app", ".", "Tag", "(", ")", "]", "=", "applicationd", "\n\n", "err", "=", "catacomb", ".", "Invoke", "(", "catacomb", ".", "Plan", "{", "Site", ":", "&", "applicationd", ".", "catacomb", ",", "Work", ":", "func", "(", ")", "error", "{", "return", "applicationd", ".", "watchLoop", "(", "exposed", ")", "\n", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "fw", ".", "catacomb", ".", "Add", "(", "applicationd", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "startApplication", "creates", "a", "new", "data", "value", "for", "tracking", "details", "of", "the", "application", "and", "starts", "watching", "the", "application", "for", "exposure", "changes", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "reconcileGlobal", "(", ")", "error", "{", "var", "machines", "[", "]", "*", "machineData", "\n", "for", "_", ",", "machined", ":=", "range", "fw", ".", "machineds", "{", "machines", "=", "append", "(", "machines", ",", "machined", ")", "\n", "}", "\n", "want", ",", "err", ":=", "fw", ".", "gatherIngressRules", "(", "machines", "...", ")", "\n", "initialPortRanges", ",", "err", ":=", "fw", ".", "environFirewaller", ".", "IngressRules", "(", "fw", ".", "cloudCallContext", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Check which ports to open or to close.", "toOpen", ",", "toClose", ":=", "diffRanges", "(", "initialPortRanges", ",", "want", ")", "\n", "if", "len", "(", "toOpen", ")", ">", "0", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "toOpen", ")", "\n", "if", "err", ":=", "fw", ".", "environFirewaller", ".", "OpenPorts", "(", "fw", ".", "cloudCallContext", ",", "toOpen", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "len", "(", "toClose", ")", ">", "0", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "toClose", ")", "\n", "if", "err", ":=", "fw", ".", "environFirewaller", ".", "ClosePorts", "(", "fw", ".", "cloudCallContext", ",", "toClose", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "reconcileGlobal", "compares", "the", "initially", "started", "watcher", "for", "machines", "units", "and", "applications", "with", "the", "opened", "and", "closed", "ports", "globally", "and", "opens", "and", "closes", "the", "appropriate", "ports", "for", "the", "whole", "environment", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "reconcileInstances", "(", ")", "error", "{", "for", "_", ",", "machined", ":=", "range", "fw", ".", "machineds", "{", "m", ",", "err", ":=", "machined", ".", "machine", "(", ")", "\n", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "if", "err", ":=", "fw", ".", "forgetMachine", "(", "machined", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "continue", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "instanceId", ",", "err", ":=", "m", ".", "InstanceId", "(", ")", "\n", "if", "errors", ".", "IsNotProvisioned", "(", "err", ")", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "envInstances", ",", "err", ":=", "fw", ".", "environInstances", ".", "Instances", "(", "fw", ".", "cloudCallContext", ",", "[", "]", "instance", ".", "Id", "{", "instanceId", "}", ")", "\n", "if", "err", "==", "environs", ".", "ErrNoInstances", "{", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "machineId", ":=", "machined", ".", "tag", ".", "Id", "(", ")", "\n\n", "fwInstance", ",", "ok", ":=", "envInstances", "[", "0", "]", ".", "(", "instances", ".", "InstanceFirewaller", ")", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n\n", "initialRules", ",", "err", ":=", "fwInstance", ".", "IngressRules", "(", "fw", ".", "cloudCallContext", ",", "machineId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Check which ports to open or to close.", "toOpen", ",", "toClose", ":=", "diffRanges", "(", "initialRules", ",", "machined", ".", "ingressRules", ")", "\n", "if", "len", "(", "toOpen", ")", ">", "0", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "toOpen", ",", "machined", ".", "tag", ")", "\n", "if", "err", ":=", "fwInstance", ".", "OpenPorts", "(", "fw", ".", "cloudCallContext", ",", "machineId", ",", "toOpen", ")", ";", "err", "!=", "nil", "{", "// TODO(mue) Add local retry logic.", "return", "err", "\n", "}", "\n", "}", "\n", "if", "len", "(", "toClose", ")", ">", "0", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "toClose", ",", "machined", ".", "tag", ")", "\n", "if", "err", ":=", "fwInstance", ".", "ClosePorts", "(", "fw", ".", "cloudCallContext", ",", "machineId", ",", "toClose", ")", ";", "err", "!=", "nil", "{", "// TODO(mue) Add local retry logic.", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "reconcileInstances", "compares", "the", "initially", "started", "watcher", "for", "machines", "units", "and", "applications", "with", "the", "opened", "and", "closed", "ports", "of", "the", "instances", "and", "opens", "and", "closes", "the", "appropriate", "ports", "for", "each", "instance", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "unitsChanged", "(", "change", "*", "unitsChange", ")", "error", "{", "changed", ":=", "[", "]", "*", "unitData", "{", "}", "\n", "for", "_", ",", "name", ":=", "range", "change", ".", "units", "{", "unitTag", ":=", "names", ".", "NewUnitTag", "(", "name", ")", "\n", "unit", ",", "err", ":=", "fw", ".", "firewallerApi", ".", "Unit", "(", "unitTag", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "var", "machineTag", "names", ".", "MachineTag", "\n", "if", "unit", "!=", "nil", "{", "machineTag", ",", "err", "=", "unit", ".", "AssignedMachine", "(", ")", "\n", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "&&", "!", "params", ".", "IsCodeNotAssigned", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "unitd", ",", "known", ":=", "fw", ".", "unitds", "[", "unitTag", "]", ";", "known", "{", "knownMachineTag", ":=", "fw", ".", "unitds", "[", "unitTag", "]", ".", "machined", ".", "tag", "\n", "if", "unit", "==", "nil", "||", "unit", ".", "Life", "(", ")", "==", "params", ".", "Dead", "||", "machineTag", "!=", "knownMachineTag", "{", "fw", ".", "forgetUnit", "(", "unitd", ")", "\n", "changed", "=", "append", "(", "changed", ",", "unitd", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "// TODO(dfc) fw.machineds should be map[names.Tag]", "}", "else", "if", "unit", "!=", "nil", "&&", "unit", ".", "Life", "(", ")", "!=", "params", ".", "Dead", "&&", "fw", ".", "machineds", "[", "machineTag", "]", "!=", "nil", "{", "err", "=", "fw", ".", "startUnit", "(", "unit", ",", "machineTag", ")", "\n", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "continue", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "changed", "=", "append", "(", "changed", ",", "fw", ".", "unitds", "[", "unitTag", "]", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "unitTag", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "fw", ".", "flushUnits", "(", "changed", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "unitsChanged", "responds", "to", "changes", "to", "the", "assigned", "units", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "openedPortsChanged", "(", "machineTag", "names", ".", "MachineTag", ",", "subnetTag", "names", ".", "SubnetTag", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "err", "=", "nil", "\n", "}", "\n", "}", "(", ")", "\n", "machined", ",", "ok", ":=", "fw", ".", "machineds", "[", "machineTag", "]", "\n", "if", "!", "ok", "{", "// It is common to receive a port change notification before", "// registering the machine, so if a machine is not found in", "// firewaller's list, just skip the change. Look up will also", "// fail if it's a manual machine.", "logger", ".", "Debugf", "(", "\"", "\"", ",", "machineTag", ")", "\n", "return", "nil", "\n", "}", "\n\n", "m", ",", "err", ":=", "machined", ".", "machine", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ports", ",", "err", ":=", "m", ".", "OpenedPorts", "(", "subnetTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "newPortRanges", ":=", "make", "(", "map", "[", "names", ".", "UnitTag", "]", "portRanges", ")", "\n", "for", "portRange", ",", "unitTag", ":=", "range", "ports", "{", "unitd", ",", "ok", ":=", "machined", ".", "unitds", "[", "unitTag", "]", "\n", "if", "!", "ok", "{", "// It is common to receive port change notification before", "// registering a unit. Skip handling the port change - it will", "// be handled when the unit is registered.", "logger", ".", "Debugf", "(", "\"", "\"", ",", "unitTag", ")", "\n", "return", "nil", "\n", "}", "\n", "ranges", ",", "ok", ":=", "newPortRanges", "[", "unitd", ".", "tag", "]", "\n", "if", "!", "ok", "{", "ranges", "=", "make", "(", "portRanges", ")", "\n", "newPortRanges", "[", "unitd", ".", "tag", "]", "=", "ranges", "\n", "}", "\n", "ranges", "[", "portRange", "]", "=", "true", "\n", "}", "\n\n", "if", "!", "unitPortsEqual", "(", "machined", ".", "definedPorts", ",", "newPortRanges", ")", "{", "machined", ".", "definedPorts", "=", "newPortRanges", "\n", "return", "fw", ".", "flushMachine", "(", "machined", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "openedPortsChanged", "handles", "port", "change", "notifications" ]

[ "func", "(", "fw", "*", "Firewaller", ")", "flushUnits", "(", "unitds", "[", "]", "*", "unitData", ")", "error", "{", "machineds", ":=", "map", "[", "names", ".", "MachineTag", "]", "*", "machineData", "{", "}", "\n", "for", "_", ",", "unitd", ":=", "range", "unitds", "{", "machineds", "[", "unitd", ".", "machined", ".", "tag", "]", "=", "unitd", ".", "machined", "\n", "}", "\n", "for", "_", ",", "machined", ":=", "range", "machineds", "{", "if", "err", ":=", "fw", ".", "flushMachine", "(", "machined", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "flushUnits", "opens", "and", "closes", "ports", "for", "the", "passed", "unit", "data", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "flushMachine", "(", "machined", "*", "machineData", ")", "error", "{", "want", ",", "err", ":=", "fw", ".", "gatherIngressRules", "(", "machined", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "toOpen", ",", "toClose", ":=", "diffRanges", "(", "machined", ".", "ingressRules", ",", "want", ")", "\n", "machined", ".", "ingressRules", "=", "want", "\n", "if", "fw", ".", "globalMode", "{", "return", "fw", ".", "flushGlobalPorts", "(", "toOpen", ",", "toClose", ")", "\n", "}", "\n", "return", "fw", ".", "flushInstancePorts", "(", "machined", ",", "toOpen", ",", "toClose", ")", "\n", "}" ]

[ "flushMachine", "opens", "and", "closes", "ports", "for", "the", "passed", "machine", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "gatherIngressRules", "(", "machines", "...", "*", "machineData", ")", "(", "[", "]", "network", ".", "IngressRule", ",", "error", ")", "{", "var", "want", "[", "]", "network", ".", "IngressRule", "\n", "for", "_", ",", "machined", ":=", "range", "machines", "{", "for", "unitTag", ",", "portRanges", ":=", "range", "machined", ".", "definedPorts", "{", "unitd", ",", "known", ":=", "machined", ".", "unitds", "[", "unitTag", "]", "\n", "if", "!", "known", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "unitTag", ",", "machined", ".", "tag", ")", "\n", "continue", "\n", "}", "\n\n", "cidrs", ":=", "set", ".", "NewStrings", "(", ")", "\n", "// If the unit is exposed, allow access from everywhere.", "if", "unitd", ".", "applicationd", ".", "exposed", "{", "cidrs", ".", "Add", "(", "\"", "\"", ")", "\n", "}", "else", "{", "// Not exposed, so add any ingress rules required by remote relations.", "if", "err", ":=", "fw", ".", "updateForRemoteRelationIngress", "(", "unitd", ".", "applicationd", ".", "application", ".", "Tag", "(", ")", ",", "cidrs", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "unitTag", ",", "cidrs", ".", "Values", "(", ")", ")", "\n", "}", "\n", "if", "cidrs", ".", "Size", "(", ")", ">", "0", "{", "for", "portRange", ":=", "range", "portRanges", "{", "sourceCidrs", ":=", "cidrs", ".", "SortedValues", "(", ")", "\n", "rule", ",", "err", ":=", "network", ".", "NewIngressRule", "(", "portRange", ".", "Protocol", ",", "portRange", ".", "FromPort", ",", "portRange", ".", "ToPort", ",", "sourceCidrs", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "want", "=", "append", "(", "want", ",", "rule", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "want", ",", "nil", "\n", "}" ]

[ "gatherIngressRules", "returns", "the", "ingress", "rules", "to", "open", "and", "close", "for", "the", "specified", "machines", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "flushGlobalPorts", "(", "rawOpen", ",", "rawClose", "[", "]", "network", ".", "IngressRule", ")", "error", "{", "// Filter which ports are really to open or close.", "var", "toOpen", ",", "toClose", "[", "]", "network", ".", "IngressRule", "\n", "for", "_", ",", "rule", ":=", "range", "rawOpen", "{", "ruleName", ":=", "rule", ".", "String", "(", ")", "\n", "if", "fw", ".", "globalIngressRuleRef", "[", "ruleName", "]", "==", "0", "{", "toOpen", "=", "append", "(", "toOpen", ",", "rule", ")", "\n", "}", "\n", "fw", ".", "globalIngressRuleRef", "[", "ruleName", "]", "++", "\n", "}", "\n", "for", "_", ",", "rule", ":=", "range", "rawClose", "{", "ruleName", ":=", "rule", ".", "String", "(", ")", "\n", "fw", ".", "globalIngressRuleRef", "[", "ruleName", "]", "--", "\n", "if", "fw", ".", "globalIngressRuleRef", "[", "ruleName", "]", "==", "0", "{", "toClose", "=", "append", "(", "toClose", ",", "rule", ")", "\n", "delete", "(", "fw", ".", "globalIngressRuleRef", ",", "ruleName", ")", "\n", "}", "\n", "}", "\n", "// Open and close the ports.", "if", "len", "(", "toOpen", ")", ">", "0", "{", "if", "err", ":=", "fw", ".", "environFirewaller", ".", "OpenPorts", "(", "fw", ".", "cloudCallContext", ",", "toOpen", ")", ";", "err", "!=", "nil", "{", "// TODO(mue) Add local retry logic.", "return", "err", "\n", "}", "\n", "network", ".", "SortIngressRules", "(", "toOpen", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "toOpen", ")", "\n", "}", "\n", "if", "len", "(", "toClose", ")", ">", "0", "{", "if", "err", ":=", "fw", ".", "environFirewaller", ".", "ClosePorts", "(", "fw", ".", "cloudCallContext", ",", "toClose", ")", ";", "err", "!=", "nil", "{", "// TODO(mue) Add local retry logic.", "return", "err", "\n", "}", "\n", "network", ".", "SortIngressRules", "(", "toClose", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "toClose", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "flushGlobalPorts", "opens", "and", "closes", "global", "ports", "in", "the", "environment", ".", "It", "keeps", "a", "reference", "count", "for", "ports", "so", "that", "only", "0", "-", "to", "-", "1", "and", "1", "-", "to", "-", "0", "events", "modify", "the", "environment", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "flushInstancePorts", "(", "machined", "*", "machineData", ",", "toOpen", ",", "toClose", "[", "]", "network", ".", "IngressRule", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "err", "=", "nil", "\n", "}", "\n", "}", "(", ")", "\n\n", "// If there's nothing to do, do nothing.", "// This is important because when a machine is first created,", "// it will have no instance id but also no open ports -", "// InstanceId will fail but we don't care.", "logger", ".", "Debugf", "(", "\"", "\"", ",", "toOpen", ",", "toClose", ")", "\n", "if", "len", "(", "toOpen", ")", "==", "0", "&&", "len", "(", "toClose", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "m", ",", "err", ":=", "machined", ".", "machine", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "machineId", ":=", "machined", ".", "tag", ".", "Id", "(", ")", "\n", "instanceId", ",", "err", ":=", "m", ".", "InstanceId", "(", ")", "\n", "if", "params", ".", "IsCodeNotProvisioned", "(", "err", ")", "{", "// Not provisioned yet, so nothing to do for this instance", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "envInstances", ",", "err", ":=", "fw", ".", "environInstances", ".", "Instances", "(", "fw", ".", "cloudCallContext", ",", "[", "]", "instance", ".", "Id", "{", "instanceId", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fwInstance", ",", "ok", ":=", "envInstances", "[", "0", "]", ".", "(", "instances", ".", "InstanceFirewaller", ")", "\n", "if", "!", "ok", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "envInstances", "[", "0", "]", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// Open and close the ports.", "if", "len", "(", "toOpen", ")", ">", "0", "{", "if", "err", ":=", "fwInstance", ".", "OpenPorts", "(", "fw", ".", "cloudCallContext", ",", "machineId", ",", "toOpen", ")", ";", "err", "!=", "nil", "{", "// TODO(mue) Add local retry logic.", "return", "err", "\n", "}", "\n", "network", ".", "SortIngressRules", "(", "toOpen", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "toOpen", ",", "machined", ".", "tag", ")", "\n", "}", "\n", "if", "len", "(", "toClose", ")", ">", "0", "{", "if", "err", ":=", "fwInstance", ".", "ClosePorts", "(", "fw", ".", "cloudCallContext", ",", "machineId", ",", "toClose", ")", ";", "err", "!=", "nil", "{", "// TODO(mue) Add local retry logic.", "return", "err", "\n", "}", "\n", "network", ".", "SortIngressRules", "(", "toClose", ")", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "toClose", ",", "machined", ".", "tag", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "flushInstancePorts", "opens", "and", "closes", "ports", "global", "on", "the", "machine", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "machineLifeChanged", "(", "tag", "names", ".", "MachineTag", ")", "error", "{", "m", ",", "err", ":=", "fw", ".", "firewallerApi", ".", "Machine", "(", "tag", ")", "\n", "found", ":=", "!", "params", ".", "IsCodeNotFound", "(", "err", ")", "\n", "if", "found", "&&", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "dead", ":=", "!", "found", "||", "m", ".", "Life", "(", ")", "==", "params", ".", "Dead", "\n", "machined", ",", "known", ":=", "fw", ".", "machineds", "[", "tag", "]", "\n", "if", "known", "&&", "dead", "{", "return", "fw", ".", "forgetMachine", "(", "machined", ")", "\n", "}", "\n", "if", "!", "known", "&&", "!", "dead", "{", "err", ":=", "fw", ".", "startMachine", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "machineLifeChanged", "starts", "watching", "new", "machines", "when", "the", "firewaller", "is", "starting", "or", "when", "new", "machines", "come", "to", "life", "and", "stops", "watching", "machines", "that", "are", "dying", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "forgetMachine", "(", "machined", "*", "machineData", ")", "error", "{", "for", "_", ",", "unitd", ":=", "range", "machined", ".", "unitds", "{", "fw", ".", "forgetUnit", "(", "unitd", ")", "\n", "}", "\n", "if", "err", ":=", "fw", ".", "flushMachine", "(", "machined", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Unusually, it's fine to ignore this error, because we know the machined", "// is being tracked in fw.catacomb. But we do still want to wait until the", "// watch loop has stopped before we nuke the last data and return.", "_", "=", "worker", ".", "Stop", "(", "machined", ")", "\n", "delete", "(", "fw", ".", "machineds", ",", "machined", ".", "tag", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "machined", ".", "tag", ")", "\n", "return", "nil", "\n", "}" ]

[ "forgetMachine", "cleans", "the", "machine", "data", "after", "the", "machine", "is", "removed", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "forgetUnit", "(", "unitd", "*", "unitData", ")", "{", "applicationd", ":=", "unitd", ".", "applicationd", "\n", "machined", ":=", "unitd", ".", "machined", "\n\n", "// If it's the last unit in the application, we'll need to stop the applicationd.", "stoppedApplication", ":=", "false", "\n", "if", "len", "(", "applicationd", ".", "unitds", ")", "==", "1", "{", "if", "_", ",", "found", ":=", "applicationd", ".", "unitds", "[", "unitd", ".", "tag", "]", ";", "found", "{", "// Unusually, it's fine to ignore this error, because we know the", "// applicationd is being tracked in fw.catacomb. But we do still want", "// to wait until the watch loop has stopped before we nuke the last", "// data and return.", "_", "=", "worker", ".", "Stop", "(", "applicationd", ")", "\n", "stoppedApplication", "=", "true", "\n", "}", "\n", "}", "\n\n", "// Clean up after stopping.", "delete", "(", "fw", ".", "unitds", ",", "unitd", ".", "tag", ")", "\n", "delete", "(", "machined", ".", "unitds", ",", "unitd", ".", "tag", ")", "\n", "delete", "(", "applicationd", ".", "unitds", ",", "unitd", ".", "tag", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "unitd", ".", "tag", ")", "\n", "if", "stoppedApplication", "{", "applicationTag", ":=", "applicationd", ".", "application", ".", "Tag", "(", ")", "\n", "delete", "(", "fw", ".", "applicationids", ",", "applicationTag", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "applicationTag", ")", "\n", "}", "\n", "}" ]

[ "forgetUnit", "cleans", "the", "unit", "data", "after", "the", "unit", "is", "removed", "." ]

[ "func", "(", "md", "*", "machineData", ")", "watchLoop", "(", "unitw", "watcher", ".", "StringsWatcher", ")", "error", "{", "if", "err", ":=", "md", ".", "catacomb", ".", "Add", "(", "unitw", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "{", "select", "{", "case", "<-", "md", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "md", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "change", ",", "ok", ":=", "<-", "unitw", ".", "Changes", "(", ")", ":", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "select", "{", "case", "<-", "md", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "md", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "md", ".", "fw", ".", "unitsChange", "<-", "&", "unitsChange", "{", "md", ",", "change", "}", ":", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "watchLoop", "watches", "the", "machine", "for", "units", "added", "or", "removed", "." ]

[ "func", "(", "ad", "*", "applicationData", ")", "watchLoop", "(", "exposed", "bool", ")", "error", "{", "appWatcher", ",", "err", ":=", "ad", ".", "application", ".", "Watch", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "ad", ".", "catacomb", ".", "Add", "(", "appWatcher", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "{", "select", "{", "case", "<-", "ad", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "ad", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "_", ",", "ok", ":=", "<-", "appWatcher", ".", "Changes", "(", ")", ":", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "change", ",", "err", ":=", "ad", ".", "application", ".", "IsExposed", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "ad", ".", "application", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "change", "==", "exposed", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "ad", ".", "application", ".", "Name", "(", ")", ",", "exposed", ")", "\n", "continue", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "ad", ".", "application", ".", "Name", "(", ")", ",", "exposed", ",", "change", ")", "\n\n", "exposed", "=", "change", "\n", "select", "{", "case", "<-", "ad", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "ad", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "ad", ".", "fw", ".", "exposedChange", "<-", "&", "exposedChange", "{", "ad", ",", "change", "}", ":", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "watchLoop", "watches", "the", "application", "s", "exposed", "flag", "for", "changes", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "relationLifeChanged", "(", "tag", "names", ".", "RelationTag", ")", "error", "{", "results", ",", "err", ":=", "fw", ".", "remoteRelationsApi", ".", "Relations", "(", "[", "]", "string", "{", "tag", ".", "Id", "(", ")", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "relErr", ":=", "results", "[", "0", "]", ".", "Error", "\n", "notfound", ":=", "relErr", "!=", "nil", "&&", "params", ".", "IsCodeNotFound", "(", "relErr", ")", "\n", "if", "relErr", "!=", "nil", "&&", "!", "notfound", "{", "return", "err", "\n", "}", "\n", "rel", ":=", "results", "[", "0", "]", ".", "Result", "\n\n", "gone", ":=", "notfound", "||", "rel", ".", "Life", "==", "params", ".", "Dead", "||", "rel", ".", "Suspended", "\n", "data", ",", "known", ":=", "fw", ".", "relationIngress", "[", "tag", "]", "\n", "if", "known", "&&", "gone", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "// If relation is suspended, shut off ingress immediately.", "// Units will also eventually leave scope which would cause", "// ingress to be shut off, but best to do it up front.", "if", "rel", "!=", "nil", "&&", "rel", ".", "Suspended", "{", "change", ":=", "&", "remoteRelationNetworkChange", "{", "relationTag", ":", "tag", ",", "localApplicationTag", ":", "data", ".", "localApplicationTag", ",", "ingressRequired", ":", "false", ",", "}", "\n", "if", "err", ":=", "fw", ".", "relationIngressChanged", "(", "change", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "fw", ".", "forgetRelation", "(", "data", ")", "\n", "}", "\n", "if", "!", "known", "&&", "!", "gone", "{", "err", ":=", "fw", ".", "startRelation", "(", "rel", ",", "rel", ".", "Endpoint", ".", "Role", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "relationLifeChanged", "manages", "the", "workers", "to", "process", "ingress", "changes", "for", "the", "specified", "relation", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "startRelation", "(", "rel", "*", "params", ".", "RemoteRelation", ",", "role", "charm", ".", "RelationRole", ")", "error", "{", "remoteApps", ",", "err", ":=", "fw", ".", "remoteRelationsApi", ".", "RemoteApplications", "(", "[", "]", "string", "{", "rel", ".", "RemoteApplicationName", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "remoteAppResult", ":=", "remoteApps", "[", "0", "]", "\n", "if", "remoteAppResult", ".", "Error", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "tag", ":=", "names", ".", "NewRelationTag", "(", "rel", ".", "Key", ")", "\n", "data", ":=", "&", "remoteRelationData", "{", "fw", ":", "fw", ",", "tag", ":", "tag", ",", "remoteModelUUID", ":", "rel", ".", "SourceModelUUID", ",", "localApplicationTag", ":", "names", ".", "NewApplicationTag", "(", "rel", ".", "ApplicationName", ")", ",", "endpointRole", ":", "role", ",", "relationReady", ":", "make", "(", "chan", "remoteRelationInfo", ")", ",", "}", "\n\n", "// Start the worker which will watch the remote relation for things like new networks.", "if", "err", ":=", "fw", ".", "relationWorkerRunner", ".", "StartWorker", "(", "tag", ".", "Id", "(", ")", ",", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "if", "err", ":=", "catacomb", ".", "Invoke", "(", "catacomb", ".", "Plan", "{", "Site", ":", "&", "data", ".", "catacomb", ",", "Work", ":", "data", ".", "watchLoop", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "data", ",", "nil", "\n", "}", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "fw", ".", "relationIngress", "[", "tag", "]", "=", "data", "\n\n", "data", ".", "isOffer", "=", "remoteAppResult", ".", "Result", ".", "IsConsumerProxy", "\n", "return", "fw", ".", "startRelationPoller", "(", "rel", ".", "Key", ",", "rel", ".", "RemoteApplicationName", ",", "data", ".", "relationReady", ")", "\n", "}" ]

[ "startRelation", "creates", "a", "new", "data", "value", "for", "tracking", "details", "of", "the", "relation", "and", "starts", "watching", "the", "related", "models", "for", "subnets", "added", "or", "removed", "." ]

[ "func", "(", "rd", "*", "remoteRelationData", ")", "watchLoop", "(", ")", "error", "{", "defer", "func", "(", ")", "{", "if", "rd", ".", "crossModelFirewallerFacade", "!=", "nil", "{", "rd", ".", "crossModelFirewallerFacade", ".", "Close", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// First, wait for relation to become ready.", "for", "rd", ".", "relationToken", "==", "\"", "\"", "{", "select", "{", "case", "<-", "rd", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "rd", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "remoteRelationInfo", ":=", "<-", "rd", ".", "relationReady", ":", "rd", ".", "relationToken", "=", "remoteRelationInfo", ".", "relationToken", "\n", "rd", ".", "applicationToken", "=", "remoteRelationInfo", ".", "applicationToken", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "rd", ".", "relationToken", ",", "rd", ".", "applicationToken", ",", "rd", ".", "remoteModelUUID", ")", "\n", "}", "\n", "}", "\n\n", "if", "rd", ".", "endpointRole", "==", "charm", ".", "RoleRequirer", "{", "return", "rd", ".", "requirerEndpointLoop", "(", ")", "\n", "}", "\n", "return", "rd", ".", "providerEndpointLoop", "(", ")", "\n", "}" ]

[ "watchLoop", "watches", "the", "relation", "for", "networks", "added", "or", "removed", "." ]

[ "func", "(", "rd", "*", "remoteRelationData", ")", "updateProviderModel", "(", "cidrs", "[", "]", "string", ")", "error", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "rd", ".", "tag", ",", "cidrs", ")", "\n", "change", ":=", "&", "remoteRelationNetworkChange", "{", "relationTag", ":", "rd", ".", "tag", ",", "localApplicationTag", ":", "rd", ".", "localApplicationTag", ",", "networks", ":", "set", ".", "NewStrings", "(", "cidrs", "...", ")", ",", "ingressRequired", ":", "len", "(", "cidrs", ")", ">", "0", ",", "}", "\n\n", "apiInfo", ",", "err", ":=", "rd", ".", "fw", ".", "firewallerApi", ".", "ControllerAPIInfoForModel", "(", "rd", ".", "remoteModelUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "rd", ".", "remoteModelUUID", ")", "\n", "}", "\n", "mac", ",", "err", ":=", "rd", ".", "fw", ".", "firewallerApi", ".", "MacaroonForRelation", "(", "rd", ".", "tag", ".", "Id", "(", ")", ")", "\n", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "// Relation has gone, nothing to do.", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "rd", ".", "tag", ".", "Id", "(", ")", ")", "\n", "}", "\n", "remoteModelAPI", ",", "err", ":=", "rd", ".", "fw", ".", "newRemoteFirewallerAPIFunc", "(", "apiInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "remoteModelAPI", ".", "Close", "(", ")", "\n", "event", ":=", "params", ".", "IngressNetworksChangeEvent", "{", "RelationToken", ":", "rd", ".", "relationToken", ",", "ApplicationToken", ":", "rd", ".", "applicationToken", ",", "Networks", ":", "change", ".", "networks", ".", "Values", "(", ")", ",", "IngressRequired", ":", "change", ".", "ingressRequired", ",", "Macaroons", ":", "macaroon", ".", "Slice", "{", "mac", "}", ",", "}", "\n", "err", "=", "remoteModelAPI", ".", "PublishIngressNetworkChange", "(", "event", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "event", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// If the requested ingress is not permitted on the offering side,", "// mark the relation as in error. It's not an error that requires a", "// worker restart though.", "if", "params", ".", "IsCodeForbidden", "(", "err", ")", "{", "return", "rd", ".", "fw", ".", "firewallerApi", ".", "SetRelationStatus", "(", "rd", ".", "tag", ".", "Id", "(", ")", ",", "relation", ".", "Error", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}" ]

[ "updateProviderModel", "gathers", "the", "ingress", "CIDRs", "for", "the", "relation", "and", "notifies", "that", "a", "change", "has", "occurred", "." ]

[ "func", "(", "rd", "*", "remoteRelationData", ")", "updateIngressNetworks", "(", "cidrs", "[", "]", "string", ")", "error", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "rd", ".", "tag", ",", "cidrs", ")", "\n", "change", ":=", "&", "remoteRelationNetworkChange", "{", "relationTag", ":", "rd", ".", "tag", ",", "localApplicationTag", ":", "rd", ".", "localApplicationTag", ",", "networks", ":", "set", ".", "NewStrings", "(", "cidrs", "...", ")", ",", "ingressRequired", ":", "len", "(", "cidrs", ")", ">", "0", ",", "}", "\n", "select", "{", "case", "<-", "rd", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "rd", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "rd", ".", "fw", ".", "localRelationsChange", "<-", "change", ":", "}", "\n", "return", "nil", "\n", "}" ]

[ "updateIngressNetworks", "processes", "the", "changed", "ingress", "networks", "on", "the", "relation", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "forgetRelation", "(", "data", "*", "remoteRelationData", ")", "error", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "data", ".", "tag", ".", "Id", "(", ")", ")", "\n", "delete", "(", "fw", ".", "relationIngress", ",", "data", ".", "tag", ")", "\n", "// There's not much we can do if there's an error stopping the remote", "// relation worker, so just log it.", "if", "err", ":=", "fw", ".", "relationWorkerRunner", ".", "StopWorker", "(", "data", ".", "tag", ".", "Id", "(", ")", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "data", ".", "tag", ",", "err", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "data", ".", "tag", ")", "\n", "return", "nil", "\n", "}" ]

[ "forgetRelation", "cleans", "the", "relation", "data", "after", "the", "relation", "is", "removed", "." ]

[ "func", "(", "fw", "*", "Firewaller", ")", "startRelationPoller", "(", "relationKey", ",", "remoteAppName", "string", ",", "relationReady", "chan", "remoteRelationInfo", ")", "error", "{", "poller", ":=", "&", "remoteRelationPoller", "{", "fw", ":", "fw", ",", "relationTag", ":", "names", ".", "NewRelationTag", "(", "relationKey", ")", ",", "applicationTag", ":", "names", ".", "NewApplicationTag", "(", "remoteAppName", ")", ",", "relationReady", ":", "relationReady", ",", "}", "\n\n", "err", ":=", "catacomb", ".", "Invoke", "(", "catacomb", ".", "Plan", "{", "Site", ":", "&", "poller", ".", "catacomb", ",", "Work", ":", "poller", ".", "pollLoop", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// register poller with the firewaller's catacomb.", "return", "fw", ".", "catacomb", ".", "Add", "(", "poller", ")", "\n", "}" ]

[ "startRelationPoller", "creates", "a", "new", "worker", "which", "waits", "until", "a", "remote", "relation", "is", "registered", "in", "both", "models", "." ]

[ "func", "(", "p", "*", "remoteRelationPoller", ")", "pollLoop", "(", ")", "error", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "p", ".", "relationTag", ",", "p", ".", "applicationTag", ")", "\n", "for", "{", "select", "{", "case", "<-", "p", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "p", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "<-", "p", ".", "fw", ".", "pollClock", ".", "After", "(", "3", "*", "time", ".", "Second", ")", ":", "// Relation is exported with the consuming model UUID.", "relToken", ",", "err", ":=", "p", ".", "fw", ".", "remoteRelationsApi", ".", "GetToken", "(", "p", ".", "relationTag", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "relToken", ",", "p", ".", "relationTag", ".", "Id", "(", ")", ",", "p", ".", "fw", ".", "modelUUID", ")", "\n\n", "// Application is exported with the offering model UUID.", "appToken", ",", "err", ":=", "p", ".", "fw", ".", "remoteRelationsApi", ".", "GetToken", "(", "p", ".", "applicationTag", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "appToken", ",", "p", ".", "applicationTag", ".", "Id", "(", ")", ")", "\n\n", "// relation and application are ready.", "relationInfo", ":=", "remoteRelationInfo", "{", "relationToken", ":", "relToken", ",", "applicationToken", ":", "appToken", ",", "}", "\n", "select", "{", "case", "<-", "p", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "p", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "p", ".", "relationReady", "<-", "relationInfo", ":", "}", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "pollLoop", "waits", "for", "a", "remote", "relation", "to", "be", "registered", ".", "It", "does", "this", "by", "waiting", "for", "the", "relation", "and", "app", "tokens", "to", "be", "created", "." ]

[ "func", "composeBundle", "(", "data", "*", "charm", ".", "BundleData", ",", "ctx", "*", "cmd", ".", "Context", ",", "bundleDir", "string", ",", "overlayFileNames", "[", "]", "string", ")", "error", "{", "if", "err", ":=", "processBundleOverlay", "(", "data", ",", "overlayFileNames", "...", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "bundleDir", "==", "\"", "\"", "{", "bundleDir", "=", "ctx", ".", "Dir", "\n", "}", "\n", "if", "err", ":=", "processBundleIncludes", "(", "bundleDir", ",", "data", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "composeBundle", "adds", "the", "overlays", "and", "bundle", "includes", "into", "the", "passed", "bundle", "data", "struct", "." ]

[ "func", "deployBundle", "(", "bundleDir", "string", ",", "data", "*", "charm", ".", "BundleData", ",", "bundleURL", "*", "charm", ".", "URL", ",", "bundleOverlayFile", "[", "]", "string", ",", "channel", "csparams", ".", "Channel", ",", "apiRoot", "DeployAPI", ",", "ctx", "*", "cmd", ".", "Context", ",", "bundleStorage", "map", "[", "string", "]", "map", "[", "string", "]", "storage", ".", "Constraints", ",", "bundleDevices", "map", "[", "string", "]", "map", "[", "string", "]", "devices", ".", "Constraints", ",", "dryRun", "bool", ",", "useExistingMachines", "bool", ",", "bundleMachines", "map", "[", "string", "]", "string", ",", ")", "(", "map", "[", "*", "charm", ".", "URL", "]", "*", "macaroon", ".", "Macaroon", ",", "error", ")", "{", "if", "err", ":=", "composeBundle", "(", "data", ",", "ctx", ",", "bundleDir", ",", "bundleOverlayFile", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "verifyBundle", "(", "data", ",", "bundleDir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// TODO: move bundle parsing and checking into the handler.", "h", ":=", "makeBundleHandler", "(", "dryRun", ",", "bundleDir", ",", "channel", ",", "apiRoot", ",", "ctx", ",", "data", ",", "bundleURL", ",", "bundleStorage", ",", "bundleDevices", ")", "\n", "if", "err", ":=", "h", ".", "makeModel", "(", "useExistingMachines", ",", "bundleMachines", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "h", ".", "resolveCharmsAndEndpoints", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "h", ".", "getChanges", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "h", ".", "handleChanges", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "h", ".", "macaroons", ",", "nil", "\n\n", "}" ]

[ "deployBundle", "deploys", "the", "given", "bundle", "data", "using", "the", "given", "API", "client", "and", "charm", "store", "client", ".", "The", "deployment", "is", "not", "transactional", "and", "its", "progress", "is", "notified", "using", "the", "given", "deployment", "logger", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "addCharm", "(", "change", "*", "bundlechanges", ".", "AddCharmChange", ")", "error", "{", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n", "id", ":=", "change", ".", "Id", "(", ")", "\n", "p", ":=", "change", ".", "Params", "\n", "// First attempt to interpret as a local path.", "if", "h", ".", "isLocalCharm", "(", "p", ".", "Charm", ")", "{", "charmPath", ":=", "p", ".", "Charm", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "charmPath", ")", "{", "charmPath", "=", "filepath", ".", "Join", "(", "h", ".", "bundleDir", ",", "charmPath", ")", "\n", "}", "\n\n", "series", ":=", "p", ".", "Series", "\n", "if", "series", "==", "\"", "\"", "{", "series", "=", "h", ".", "data", ".", "Series", "\n", "}", "\n", "ch", ",", "curl", ",", "err", ":=", "charmrepo", ".", "NewCharmAtPath", "(", "charmPath", ",", "series", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "charmPath", ")", "\n", "}", "\n", "if", "err", "==", "nil", "{", "if", "err", ":=", "lxdprofile", ".", "ValidateLXDProfile", "(", "lxdCharmProfiler", "{", "Charm", ":", "ch", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "charmPath", ")", "\n", "}", "\n", "if", "curl", ",", "err", "=", "h", ".", "api", ".", "AddLocalCharm", "(", "curl", ",", "ch", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "curl", ")", "\n", "h", ".", "results", "[", "id", "]", "=", "curl", ".", "String", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "// Not a local charm, so grab from the store.", "ch", ",", "err", ":=", "charm", ".", "ParseURL", "(", "p", ".", "Charm", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "url", ",", "channel", ",", "_", ",", "err", ":=", "resolveCharm", "(", "h", ".", "api", ".", "ResolveWithChannel", ",", "ch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "p", ".", "Charm", ")", "\n", "}", "\n", "if", "url", ".", "Series", "==", "\"", "\"", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "Charm", ")", "\n", "}", "\n", "var", "macaroon", "*", "macaroon", ".", "Macaroon", "\n", "url", ",", "macaroon", ",", "err", "=", "addCharmFromURL", "(", "h", ".", "api", ",", "url", ",", "channel", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "p", ".", "Charm", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "url", ")", "\n", "h", ".", "results", "[", "id", "]", "=", "url", ".", "String", "(", ")", "\n", "h", ".", "macaroons", "[", "url", "]", "=", "macaroon", "\n", "h", ".", "channels", "[", "url", "]", "=", "channel", "\n", "return", "nil", "\n", "}" ]

[ "addCharm", "adds", "a", "charm", "to", "the", "environment", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "scaleApplication", "(", "change", "*", "bundlechanges", ".", "ScaleChange", ")", "error", "{", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n\n", "p", ":=", "change", ".", "Params", "\n\n", "result", ",", "err", ":=", "h", ".", "api", ".", "ScaleApplication", "(", "application", ".", "ScaleApplicationParams", "{", "ApplicationName", ":", "p", ".", "Application", ",", "Scale", ":", "p", ".", "Scale", ",", "}", ")", "\n", "if", "err", "==", "nil", "&&", "result", ".", "Error", "!=", "nil", "{", "err", "=", "result", ".", "Error", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "p", ".", "Application", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "scaleApplication", "updates", "the", "number", "of", "units", "for", "an", "application", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "addRelation", "(", "change", "*", "bundlechanges", ".", "AddRelationChange", ")", "error", "{", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n", "p", ":=", "change", ".", "Params", "\n", "ep1", ":=", "resolveRelation", "(", "p", ".", "Endpoint1", ",", "h", ".", "results", ")", "\n", "ep2", ":=", "resolveRelation", "(", "p", ".", "Endpoint2", ",", "h", ".", "results", ")", "\n", "// TODO(wallyworld) - CMR support in bundles", "_", ",", "err", ":=", "h", ".", "api", ".", "AddRelation", "(", "[", "]", "string", "{", "ep1", ",", "ep2", "}", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "// TODO(thumper): remove this error check when we add resolving", "// implicit relations.", "if", "params", ".", "IsCodeAlreadyExists", "(", "err", ")", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "ep1", ",", "ep2", ")", "\n\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "addRelation", "creates", "a", "relationship", "between", "two", "applications", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "addUnit", "(", "change", "*", "bundlechanges", ".", "AddUnitChange", ")", "error", "{", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n\n", "p", ":=", "change", ".", "Params", "\n", "applicationName", ":=", "resolve", "(", "p", ".", "Application", ",", "h", ".", "results", ")", "\n", "var", "err", "error", "\n", "var", "placementArg", "[", "]", "*", "instance", ".", "Placement", "\n", "targetMachine", ":=", "p", ".", "To", "\n", "if", "targetMachine", "!=", "\"", "\"", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "targetMachine", ")", "\n", "// The placement maybe \"container:machine\"", "container", ":=", "\"", "\"", "\n", "if", "parts", ":=", "strings", ".", "Split", "(", "targetMachine", ",", "\"", "\"", ")", ";", "len", "(", "parts", ")", ">", "1", "{", "container", "=", "parts", "[", "0", "]", "\n", "targetMachine", "=", "parts", "[", "1", "]", "\n", "}", "\n", "targetMachine", ",", "err", "=", "h", ".", "resolveMachine", "(", "targetMachine", ")", "\n", "if", "err", "!=", "nil", "{", "// Should never happen.", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "applicationName", ")", "\n", "}", "\n", "directive", ":=", "targetMachine", "\n", "if", "container", "!=", "\"", "\"", "{", "directive", "=", "container", "+", "\"", "\"", "+", "directive", "\n", "}", "\n", "placement", ",", "err", ":=", "parsePlacement", "(", "directive", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "directive", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "directive", ")", "\n", "placementArg", "=", "append", "(", "placementArg", ",", "placement", ")", "\n", "}", "\n", "r", ",", "err", ":=", "h", ".", "api", ".", "AddUnits", "(", "application", ".", "AddUnitsParams", "{", "ApplicationName", ":", "applicationName", ",", "NumUnits", ":", "1", ",", "Placement", ":", "placementArg", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "applicationName", ")", "\n", "}", "\n", "unit", ":=", "r", "[", "0", "]", "\n", "if", "targetMachine", "==", "\"", "\"", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "unit", ")", "\n", "// In this case, the unit name is stored in results instead of the", "// machine id, which is lazily evaluated later only if required.", "// This way we avoid waiting for watcher updates.", "h", ".", "results", "[", "change", ".", "Id", "(", ")", "]", "=", "unit", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "unit", ")", "\n", "h", ".", "results", "[", "change", ".", "Id", "(", ")", "]", "=", "targetMachine", "\n", "}", "\n\n", "// Note that the targetMachine can be empty for now, resulting in a partially", "// incomplete unit status. That's ok as the missing info is provided later", "// when it is required.", "h", ".", "unitStatus", "[", "unit", "]", "=", "targetMachine", "\n", "return", "nil", "\n", "}" ]

[ "addUnit", "adds", "a", "single", "unit", "to", "an", "application", "already", "present", "in", "the", "environment", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "upgradeCharm", "(", "change", "*", "bundlechanges", ".", "UpgradeCharmChange", ")", "error", "{", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n\n", "p", ":=", "change", ".", "Params", "\n", "cURL", ",", "err", ":=", "charm", ".", "ParseURL", "(", "resolve", "(", "p", ".", "Charm", ",", "h", ".", "results", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "chID", ":=", "charmstore", ".", "CharmID", "{", "URL", ":", "cURL", ",", "Channel", ":", "h", ".", "channels", "[", "cURL", "]", ",", "}", "\n", "macaroon", ":=", "h", ".", "macaroons", "[", "cURL", "]", "\n\n", "meta", ",", "err", ":=", "getMetaResources", "(", "cURL", ",", "h", ".", "api", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "resources", ":=", "h", ".", "makeResourceMap", "(", "meta", ",", "p", ".", "Resources", ",", "p", ".", "LocalResources", ")", "\n\n", "resourceLister", ",", "err", ":=", "resourceadapters", ".", "NewAPIClient", "(", "h", ".", "api", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "filtered", ",", "err", ":=", "getUpgradeResources", "(", "resourceLister", ",", "p", ".", "Application", ",", "resources", ",", "meta", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "resNames2IDs", "map", "[", "string", "]", "string", "\n", "if", "len", "(", "filtered", ")", "!=", "0", "{", "resNames2IDs", ",", "err", "=", "resourceadapters", ".", "DeployResources", "(", "p", ".", "Application", ",", "chID", ",", "macaroon", ",", "resources", ",", "filtered", ",", "h", ".", "api", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "cfg", ":=", "application", ".", "SetCharmConfig", "{", "ApplicationName", ":", "p", ".", "Application", ",", "CharmID", ":", "chID", ",", "ResourceIDs", ":", "resNames2IDs", ",", "}", "\n", "// Bundles only ever deal with the current generation.", "if", "err", ":=", "h", ".", "api", ".", "SetCharm", "(", "model", ".", "GenerationMaster", ",", "cfg", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "h", ".", "writeAddedResources", "(", "resNames2IDs", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "upgradeCharm", "will", "get", "the", "application", "to", "use", "the", "new", "charm", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "setOptions", "(", "change", "*", "bundlechanges", ".", "SetOptionsChange", ")", "error", "{", "p", ":=", "change", ".", "Params", "\n", "h", ".", "ctx", ".", "Verbosef", "(", "\"", "\"", ")", "\n", "for", "key", ",", "value", ":=", "range", "p", ".", "Options", "{", "switch", "value", ".", "(", "type", ")", "{", "case", "string", ":", "h", ".", "ctx", ".", "Verbosef", "(", "\"", "\"", ",", "key", ",", "value", ")", "\n", "default", ":", "h", ".", "ctx", ".", "Verbosef", "(", "\"", "\"", ",", "key", ",", "value", ")", "\n", "}", "\n", "}", "\n", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n\n", "// We know that there wouldn't be any setOptions if there were no options.", "cfg", ",", "err", ":=", "yaml", ".", "Marshal", "(", "map", "[", "string", "]", "map", "[", "string", "]", "interface", "{", "}", "{", "p", ".", "Application", ":", "p", ".", "Options", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "p", ".", "Application", ")", "\n", "}", "\n\n", "if", "err", ":=", "h", ".", "api", ".", "Update", "(", "params", ".", "ApplicationUpdate", "{", "ApplicationName", ":", "p", ".", "Application", ",", "SettingsYAML", ":", "string", "(", "cfg", ")", ",", "Generation", ":", "model", ".", "GenerationMaster", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "p", ".", "Application", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "setOptions", "updates", "application", "configuration", "settings", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "setConstraints", "(", "change", "*", "bundlechanges", ".", "SetConstraintsChange", ")", "error", "{", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n", "p", ":=", "change", ".", "Params", "\n", "// We know that p.Constraints is a valid constraints type due to the validation.", "cons", ",", "_", ":=", "constraints", ".", "Parse", "(", "p", ".", "Constraints", ")", "\n", "if", "err", ":=", "h", ".", "api", ".", "SetConstraints", "(", "p", ".", "Application", ",", "cons", ")", ";", "err", "!=", "nil", "{", "// This should never happen, as the bundle is already verified.", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "p", ".", "Application", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "setConstraints", "updates", "application", "constraints", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "exposeApplication", "(", "change", "*", "bundlechanges", ".", "ExposeChange", ")", "error", "{", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n\n", "application", ":=", "resolve", "(", "change", ".", "Params", ".", "Application", ",", "h", ".", "results", ")", "\n", "if", "err", ":=", "h", ".", "api", ".", "Expose", "(", "application", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "application", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "exposeApplication", "exposes", "an", "application", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "setAnnotations", "(", "change", "*", "bundlechanges", ".", "SetAnnotationsChange", ")", "error", "{", "p", ":=", "change", ".", "Params", "\n", "h", ".", "ctx", ".", "Verbosef", "(", "\"", "\"", ")", "\n", "for", "key", ",", "value", ":=", "range", "p", ".", "Annotations", "{", "h", ".", "ctx", ".", "Verbosef", "(", "\"", "\"", ",", "key", ",", "value", ")", "\n", "}", "\n", "if", "h", ".", "dryRun", "{", "return", "nil", "\n", "}", "\n", "eid", ":=", "resolve", "(", "p", ".", "Id", ",", "h", ".", "results", ")", "\n", "var", "tag", "string", "\n", "switch", "p", ".", "EntityType", "{", "case", "bundlechanges", ".", "MachineType", ":", "tag", "=", "names", ".", "NewMachineTag", "(", "eid", ")", ".", "String", "(", ")", "\n", "case", "bundlechanges", ".", "ApplicationType", ":", "tag", "=", "names", ".", "NewApplicationTag", "(", "eid", ")", ".", "String", "(", ")", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "EntityType", ")", "\n", "}", "\n", "result", ",", "err", ":=", "h", ".", "api", ".", "SetAnnotation", "(", "map", "[", "string", "]", "map", "[", "string", "]", "string", "{", "tag", ":", "p", ".", "Annotations", "}", ")", "\n", "if", "err", "==", "nil", "&&", "len", "(", "result", ")", ">", "0", "{", "err", "=", "result", "[", "0", "]", ".", "Error", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "p", ".", "EntityType", ",", "eid", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setAnnotations", "sets", "annotations", "for", "an", "application", "or", "a", "machine", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "applicationsForMachineChange", "(", "changeId", "string", ")", "[", "]", "string", "{", "applications", ":=", "set", ".", "NewStrings", "(", ")", "\n", "mainloop", ":", "for", "_", ",", "change", ":=", "range", "h", ".", "changes", "{", "for", "_", ",", "required", ":=", "range", "change", ".", "Requires", "(", ")", "{", "if", "required", "!=", "changeId", "{", "continue", "\n", "}", "\n", "switch", "change", ":=", "change", ".", "(", "type", ")", "{", "case", "*", "bundlechanges", ".", "AddMachineChange", ":", "// The original machine is a container, and its parent is", "// another \"addMachines\" change. Search again using the", "// parent id.", "for", "_", ",", "application", ":=", "range", "h", ".", "applicationsForMachineChange", "(", "change", ".", "Id", "(", ")", ")", "{", "applications", ".", "Add", "(", "application", ")", "\n", "}", "\n", "continue", "mainloop", "\n", "case", "*", "bundlechanges", ".", "AddUnitChange", ":", "// We have found the \"addUnit\" change, which refers to a", "// application: now resolve the application holding the unit.", "application", ":=", "resolve", "(", "change", ".", "Params", ".", "Application", ",", "h", ".", "results", ")", "\n", "applications", ".", "Add", "(", "application", ")", "\n", "continue", "mainloop", "\n", "case", "*", "bundlechanges", ".", "SetAnnotationsChange", ":", "// A machine change is always required to set machine", "// annotations, but this isn't the interesting change here.", "continue", "mainloop", "\n", "default", ":", "// Should never happen.", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "change", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "applications", ".", "SortedValues", "(", ")", "\n", "}" ]

[ "applicationsForMachineChange", "returns", "the", "names", "of", "the", "applications", "for", "which", "an", "addMachine", "change", "is", "required", "as", "adding", "machines", "is", "required", "to", "place", "units", "and", "units", "belong", "to", "applications", ".", "Receive", "the", "id", "of", "the", "addMachine", "change", "." ]

[ "func", "(", "h", "*", "bundleHandler", ")", "resolveMachine", "(", "placeholder", "string", ")", "(", "string", ",", "error", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "placeholder", ")", "\n", "machineOrUnit", ":=", "resolve", "(", "placeholder", ",", "h", ".", "results", ")", "\n", "if", "!", "names", ".", "IsValidUnit", "(", "machineOrUnit", ")", "{", "return", "machineOrUnit", ",", "nil", "\n", "}", "\n", "for", "h", ".", "unitStatus", "[", "machineOrUnit", "]", "==", "\"", "\"", "{", "if", "err", ":=", "h", ".", "updateUnitStatus", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "h", ".", "unitStatus", "[", "machineOrUnit", "]", ",", "nil", "\n", "}" ]

[ "resolveMachine", "returns", "the", "machine", "id", "resolving", "the", "given", "unit", "or", "machine", "placeholder", "." ]

[ "func", "resolveRelation", "(", "e", "string", ",", "results", "map", "[", "string", "]", "string", ")", "string", "{", "parts", ":=", "strings", ".", "SplitN", "(", "e", ",", "\"", "\"", ",", "2", ")", "\n", "application", ":=", "resolve", "(", "parts", "[", "0", "]", ",", "results", ")", "\n", "if", "len", "(", "parts", ")", "==", "1", "{", "return", "application", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "application", ",", "parts", "[", "1", "]", ")", "\n", "}" ]

[ "resolveRelation", "returns", "the", "relation", "name", "resolving", "the", "included", "application", "placeholder", "." ]

[ "func", "removeRelations", "(", "data", "[", "]", "[", "]", "string", ",", "appName", "string", ")", "[", "]", "[", "]", "string", "{", "var", "result", "[", "]", "[", "]", "string", "\n", "for", "_", ",", "relation", ":=", "range", "data", "{", "// Keep the dud relation in the set, it will be caught by the bundle", "// verify code.", "if", "len", "(", "relation", ")", "==", "2", "{", "left", ",", "right", ":=", "relation", "[", "0", "]", ",", "relation", "[", "1", "]", "\n", "if", "left", "==", "appName", "||", "strings", ".", "HasPrefix", "(", "left", ",", "appName", "+", "\"", "\"", ")", "||", "right", "==", "appName", "||", "strings", ".", "HasPrefix", "(", "right", ",", "appName", "+", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "}", "\n", "result", "=", "append", "(", "result", ",", "relation", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "removeRelations", "removes", "any", "relation", "defined", "in", "data", "that", "references", "the", "application", "appName", "." ]

[ "func", "applicationConfigValue", "(", "key", "string", ",", "valueMap", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "vm", ",", "ok", ":=", "valueMap", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "valueMap", ",", "key", ")", "\n", "}", "\n", "source", ",", "found", ":=", "vm", "[", "\"", "\"", "]", "\n", "if", "!", "found", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "if", "source", "!=", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "value", ",", "found", ":=", "vm", "[", "\"", "\"", "]", "\n", "if", "!", "found", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "value", ",", "nil", "\n", "}" ]

[ "applicationConfigValue", "returns", "the", "value", "if", "it", "is", "not", "a", "default", "value", ".", "If", "the", "value", "is", "a", "default", "value", "nil", "is", "returned", ".", "If", "there", "was", "issue", "determining", "the", "type", "or", "value", "an", "error", "is", "returned", "." ]

[ "func", "attachVolumes", "(", "ctx", "*", "context", ",", "ops", "map", "[", "params", ".", "MachineStorageId", "]", "*", "attachVolumeOp", ")", "error", "{", "volumeAttachmentParams", ":=", "make", "(", "[", "]", "storage", ".", "VolumeAttachmentParams", ",", "0", ",", "len", "(", "ops", ")", ")", "\n", "for", "_", ",", "op", ":=", "range", "ops", "{", "volumeAttachmentParams", "=", "append", "(", "volumeAttachmentParams", ",", "op", ".", "args", ")", "\n", "}", "\n", "paramsBySource", ",", "volumeSources", ",", "err", ":=", "volumeAttachmentParamsBySource", "(", "ctx", ".", "config", ".", "StorageDir", ",", "volumeAttachmentParams", ",", "ctx", ".", "config", ".", "Registry", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "reschedule", "[", "]", "scheduleOp", "\n", "var", "volumeAttachments", "[", "]", "storage", ".", "VolumeAttachment", "\n", "var", "statuses", "[", "]", "params", ".", "EntityStatusArgs", "\n", "for", "sourceName", ",", "volumeAttachmentParams", ":=", "range", "paramsBySource", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "volumeAttachmentParams", ")", "\n", "volumeSource", ":=", "volumeSources", "[", "sourceName", "]", "\n", "if", "volumeSource", "==", "nil", "{", "// The storage provider does not support dynamic", "// storage, there's nothing for the provisioner", "// to do here.", "continue", "\n", "}", "\n", "results", ",", "err", ":=", "volumeSource", ".", "AttachVolumes", "(", "ctx", ".", "config", ".", "CloudCallContext", ",", "volumeAttachmentParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "sourceName", ")", "\n", "}", "\n\n", "for", "i", ",", "result", ":=", "range", "results", "{", "p", ":=", "volumeAttachmentParams", "[", "i", "]", "\n", "statuses", "=", "append", "(", "statuses", ",", "params", ".", "EntityStatusArgs", "{", "Tag", ":", "p", ".", "Volume", ".", "String", "(", ")", ",", "Status", ":", "status", ".", "Attached", ".", "String", "(", ")", ",", "}", ")", "\n", "entityStatus", ":=", "&", "statuses", "[", "len", "(", "statuses", ")", "-", "1", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "// Reschedule the volume attachment.", "id", ":=", "params", ".", "MachineStorageId", "{", "MachineTag", ":", "p", ".", "Machine", ".", "String", "(", ")", ",", "AttachmentTag", ":", "p", ".", "Volume", ".", "String", "(", ")", ",", "}", "\n", "reschedule", "=", "append", "(", "reschedule", ",", "ops", "[", "id", "]", ")", "\n\n", "// Note: we keep the status as \"attaching\" to", "// indicate that we will retry. When we distinguish", "// between transient and permanent errors, we will", "// set the status to \"error\" for permanent errors.", "entityStatus", ".", "Status", "=", "status", ".", "Attaching", ".", "String", "(", ")", "\n", "entityStatus", ".", "Info", "=", "result", ".", "Error", ".", "Error", "(", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "names", ".", "ReadableString", "(", "p", ".", "Volume", ")", ",", "names", ".", "ReadableString", "(", "p", ".", "Machine", ")", ",", "result", ".", "Error", ",", ")", "\n", "continue", "\n", "}", "\n", "volumeAttachments", "=", "append", "(", "volumeAttachments", ",", "*", "result", ".", "VolumeAttachment", ")", "\n", "}", "\n", "}", "\n", "scheduleOperations", "(", "ctx", ",", "reschedule", "...", ")", "\n", "setStatus", "(", "ctx", ",", "statuses", ")", "\n", "if", "err", ":=", "createVolumeAttachmentPlans", "(", "ctx", ",", "volumeAttachments", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "setVolumeAttachmentInfo", "(", "ctx", ",", "volumeAttachments", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "attachVolumes", "creates", "volume", "attachments", "with", "the", "specified", "parameters", "." ]

[ "func", "createVolumeAttachmentPlans", "(", "ctx", "*", "context", ",", "volumeAttachments", "[", "]", "storage", ".", "VolumeAttachment", ")", "error", "{", "// NOTE(gsamfira): should we merge this with setVolumeInfo?", "if", "len", "(", "volumeAttachments", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "volumeAttachmentPlans", ":=", "make", "(", "[", "]", "params", ".", "VolumeAttachmentPlan", ",", "len", "(", "volumeAttachments", ")", ")", "\n", "for", "i", ",", "val", ":=", "range", "volumeAttachments", "{", "volumeAttachmentPlans", "[", "i", "]", "=", "volumeAttachmentPlanFromAttachment", "(", "val", ")", "\n", "}", "\n\n", "errorResults", ",", "err", ":=", "ctx", ".", "config", ".", "Volumes", ".", "CreateVolumeAttachmentPlans", "(", "volumeAttachmentPlans", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "i", ",", "result", ":=", "range", "errorResults", "{", "if", "result", ".", "Error", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "result", ".", "Error", ",", "\"", "\"", ",", "names", ".", "ReadableString", "(", "volumeAttachments", "[", "i", "]", ".", "Volume", ")", ",", "names", ".", "ReadableString", "(", "volumeAttachments", "[", "i", "]", ".", "Machine", ")", ",", ")", "\n", "}", "\n", "// Record the volume attachment in the context.", "id", ":=", "params", ".", "MachineStorageId", "{", "MachineTag", ":", "volumeAttachmentPlans", "[", "i", "]", ".", "MachineTag", ",", "AttachmentTag", ":", "volumeAttachmentPlans", "[", "i", "]", ".", "VolumeTag", ",", "}", "\n", "ctx", ".", "volumeAttachments", "[", "id", "]", "=", "volumeAttachments", "[", "i", "]", "\n", "// removePendingVolumeAttachment(ctx, id)", "}", "\n", "return", "nil", "\n", "}" ]

[ "createVolumeAttachmentPlans", "creates", "a", "volume", "info", "plan", "in", "state", "which", "notifies", "the", "machine", "agent", "of", "the", "target", "instance", "that", "something", "has", "been", "attached", "to", "it", "." ]

[ "func", "detachVolumes", "(", "ctx", "*", "context", ",", "ops", "map", "[", "params", ".", "MachineStorageId", "]", "*", "detachVolumeOp", ")", "error", "{", "volumeAttachmentParams", ":=", "make", "(", "[", "]", "storage", ".", "VolumeAttachmentParams", ",", "0", ",", "len", "(", "ops", ")", ")", "\n", "for", "_", ",", "op", ":=", "range", "ops", "{", "volumeAttachmentParams", "=", "append", "(", "volumeAttachmentParams", ",", "op", ".", "args", ")", "\n", "}", "\n", "paramsBySource", ",", "volumeSources", ",", "err", ":=", "volumeAttachmentParamsBySource", "(", "ctx", ".", "config", ".", "StorageDir", ",", "volumeAttachmentParams", ",", "ctx", ".", "config", ".", "Registry", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "reschedule", "[", "]", "scheduleOp", "\n", "var", "statuses", "[", "]", "params", ".", "EntityStatusArgs", "\n", "var", "remove", "[", "]", "params", ".", "MachineStorageId", "\n", "for", "sourceName", ",", "volumeAttachmentParams", ":=", "range", "paramsBySource", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "volumeAttachmentParams", ")", "\n", "volumeSource", ":=", "volumeSources", "[", "sourceName", "]", "\n", "if", "volumeSource", "==", "nil", "{", "// The storage provider does not support dynamic", "// storage, there's nothing for the provisioner", "// to do here.", "continue", "\n", "}", "\n", "errs", ",", "err", ":=", "volumeSource", ".", "DetachVolumes", "(", "ctx", ".", "config", ".", "CloudCallContext", ",", "volumeAttachmentParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "sourceName", ")", "\n", "}", "\n", "for", "i", ",", "err", ":=", "range", "errs", "{", "p", ":=", "volumeAttachmentParams", "[", "i", "]", "\n", "statuses", "=", "append", "(", "statuses", ",", "params", ".", "EntityStatusArgs", "{", "Tag", ":", "p", ".", "Volume", ".", "String", "(", ")", ",", "// TODO(axw) when we support multiple", "// attachment, we'll have to check if", "// there are any other attachments", "// before saying the status \"detached\".", "Status", ":", "status", ".", "Detached", ".", "String", "(", ")", ",", "}", ")", "\n", "id", ":=", "params", ".", "MachineStorageId", "{", "MachineTag", ":", "p", ".", "Machine", ".", "String", "(", ")", ",", "AttachmentTag", ":", "p", ".", "Volume", ".", "String", "(", ")", ",", "}", "\n", "entityStatus", ":=", "&", "statuses", "[", "len", "(", "statuses", ")", "-", "1", "]", "\n", "if", "err", "!=", "nil", "{", "reschedule", "=", "append", "(", "reschedule", ",", "ops", "[", "id", "]", ")", "\n", "entityStatus", ".", "Status", "=", "status", ".", "Detaching", ".", "String", "(", ")", "\n", "entityStatus", ".", "Info", "=", "err", ".", "Error", "(", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "names", ".", "ReadableString", "(", "p", ".", "Volume", ")", ",", "names", ".", "ReadableString", "(", "p", ".", "Machine", ")", ",", "err", ",", ")", "\n", "continue", "\n", "}", "\n", "remove", "=", "append", "(", "remove", ",", "id", ")", "\n", "}", "\n", "}", "\n", "scheduleOperations", "(", "ctx", ",", "reschedule", "...", ")", "\n", "setStatus", "(", "ctx", ",", "statuses", ")", "\n", "if", "err", ":=", "removeAttachments", "(", "ctx", ",", "remove", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "id", ":=", "range", "remove", "{", "delete", "(", "ctx", ".", "volumeAttachments", ",", "id", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "detachVolumes", "destroys", "volume", "attachments", "with", "the", "specified", "parameters", "." ]

[ "func", "validateVolumeParams", "(", "volumeSource", "storage", ".", "VolumeSource", ",", "volumeParams", "[", "]", "storage", ".", "VolumeParams", ",", ")", "(", "[", "]", "storage", ".", "VolumeParams", ",", "[", "]", "error", ")", "{", "valid", ":=", "make", "(", "[", "]", "storage", ".", "VolumeParams", ",", "0", ",", "len", "(", "volumeParams", ")", ")", "\n", "results", ":=", "make", "(", "[", "]", "error", ",", "len", "(", "volumeParams", ")", ")", "\n", "for", "i", ",", "params", ":=", "range", "volumeParams", "{", "err", ":=", "volumeSource", ".", "ValidateVolumeParams", "(", "params", ")", "\n", "if", "err", "==", "nil", "{", "valid", "=", "append", "(", "valid", ",", "params", ")", "\n", "}", "\n", "results", "[", "i", "]", "=", "err", "\n", "}", "\n", "return", "valid", ",", "results", "\n", "}" ]

[ "validateVolumeParams", "validates", "a", "collection", "of", "volume", "parameters", "." ]

[ "func", "volumeAttachmentParamsBySource", "(", "baseStorageDir", "string", ",", "params", "[", "]", "storage", ".", "VolumeAttachmentParams", ",", "registry", "storage", ".", "ProviderRegistry", ",", ")", "(", "map", "[", "string", "]", "[", "]", "storage", ".", "VolumeAttachmentParams", ",", "map", "[", "string", "]", "storage", ".", "VolumeSource", ",", "error", ")", "{", "// TODO(axw) later we may have multiple instantiations (sources)", "// for a storage provider, e.g. multiple Ceph installations. For", "// now we assume a single source for each provider type, with no", "// configuration.", "volumeSources", ":=", "make", "(", "map", "[", "string", "]", "storage", ".", "VolumeSource", ")", "\n", "paramsBySource", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "storage", ".", "VolumeAttachmentParams", ")", "\n", "for", "_", ",", "params", ":=", "range", "params", "{", "sourceName", ":=", "string", "(", "params", ".", "Provider", ")", "\n", "paramsBySource", "[", "sourceName", "]", "=", "append", "(", "paramsBySource", "[", "sourceName", "]", ",", "params", ")", "\n", "if", "_", ",", "ok", ":=", "volumeSources", "[", "sourceName", "]", ";", "ok", "{", "continue", "\n", "}", "\n", "volumeSource", ",", "err", ":=", "volumeSource", "(", "baseStorageDir", ",", "sourceName", ",", "params", ".", "Provider", ",", "registry", ",", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "errNonDynamic", "{", "volumeSource", "=", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "volumeSources", "[", "sourceName", "]", "=", "volumeSource", "\n", "}", "\n", "return", "paramsBySource", ",", "volumeSources", ",", "nil", "\n", "}" ]

[ "volumeAttachmentParamsBySource", "separates", "the", "volume", "attachment", "parameters", "by", "volume", "source", "." ]

[ "func", "(", "c", "*", "Config", ")", "Validate", "(", ")", "error", "{", "if", "c", ".", "SocketName", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "PrometheusGatherer", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "the", "config", "values", "to", "assert", "they", "are", "valid", "to", "create", "the", "worker", "." ]

[ "func", "NewWorker", "(", "config", "Config", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "if", "err", ":=", "config", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "runtime", ".", "GOOS", "!=", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ",", "runtime", ".", "GOOS", ")", "\n", "}", "\n\n", "path", ":=", "\"", "\"", "+", "config", ".", "SocketName", "\n", "addr", ",", "err", ":=", "net", ".", "ResolveUnixAddr", "(", "\"", "\"", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "l", ",", "err", ":=", "net", ".", "ListenUnix", "(", "\"", "\"", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "path", ")", "\n\n", "w", ":=", "&", "socketListener", "{", "listener", ":", "l", ",", "depEngine", ":", "config", ".", "DepEngine", ",", "statePool", ":", "config", ".", "StatePool", ",", "pubsub", ":", "config", ".", "PubSub", ",", "machineLock", ":", "config", ".", "MachineLock", ",", "prometheusGatherer", ":", "config", ".", "PrometheusGatherer", ",", "presence", ":", "config", ".", "Presence", ",", "done", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "go", "w", ".", "serve", "(", ")", "\n", "w", ".", "tomb", ".", "Go", "(", "w", ".", "run", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "NewWorker", "starts", "an", "http", "server", "listening", "on", "an", "abstract", "domain", "socket", "which", "will", "be", "created", "with", "the", "specified", "name", "." ]

[ "func", "RegisterHTTPHandlers", "(", "sources", "ReportSources", ",", "handle", "func", "(", "path", "string", ",", "h", "http", ".", "Handler", ")", ",", ")", "{", "handle", "(", "\"", "\"", ",", "http", ".", "HandlerFunc", "(", "pprof", ".", "Index", ")", ")", "\n", "handle", "(", "\"", "\"", ",", "http", ".", "HandlerFunc", "(", "pprof", ".", "Cmdline", ")", ")", "\n", "handle", "(", "\"", "\"", ",", "http", ".", "HandlerFunc", "(", "pprof", ".", "Profile", ")", ")", "\n", "handle", "(", "\"", "\"", ",", "http", ".", "HandlerFunc", "(", "pprof", ".", "Symbol", ")", ")", "\n", "handle", "(", "\"", "\"", ",", "http", ".", "HandlerFunc", "(", "pprof", ".", "Trace", ")", ")", "\n", "handle", "(", "\"", "\"", ",", "depengineHandler", "{", "sources", ".", "DependencyEngine", "}", ")", "\n", "handle", "(", "\"", "\"", ",", "introspectionReporterHandler", "{", "name", ":", "\"", "\"", ",", "reporter", ":", "sources", ".", "StatePool", ",", "}", ")", "\n", "handle", "(", "\"", "\"", ",", "introspectionReporterHandler", "{", "name", ":", "\"", "\"", ",", "reporter", ":", "sources", ".", "PubSub", ",", "}", ")", "\n", "handle", "(", "\"", "\"", ",", "promhttp", ".", "HandlerFor", "(", "sources", ".", "PrometheusGatherer", ",", "promhttp", ".", "HandlerOpts", "{", "}", ")", ")", "\n", "// Unit agents don't have a presence recorder to pass in.", "if", "sources", ".", "Presence", "!=", "nil", "{", "handle", "(", "\"", "\"", ",", "presenceHandler", "{", "sources", ".", "Presence", "}", ")", "\n", "}", "\n", "handle", "(", "\"", "\"", ",", "machineLockHandler", "{", "sources", ".", "MachineLock", "}", ")", "\n", "}" ]

[ "AddHandlers", "calls", "the", "given", "function", "with", "http", ".", "Handlers", "that", "serve", "agent", "introspection", "requests", ".", "The", "function", "will", "be", "called", "with", "a", "path", ";", "the", "function", "may", "alter", "the", "path", "as", "it", "sees", "fit", "." ]

[ "func", "(", "fw", "Watchers", ")", "WatchModelManagedFilesystems", "(", ")", "state", ".", "StringsWatcher", "{", "return", "newFilteredStringsWatcher", "(", "fw", ".", "Backend", ".", "WatchModelFilesystems", "(", ")", ",", "func", "(", "id", "string", ")", "(", "bool", ",", "error", ")", "{", "f", ",", "err", ":=", "fw", ".", "Backend", ".", "Filesystem", "(", "names", ".", "NewFilesystemTag", "(", "id", ")", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "false", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "f", ".", "Volume", "(", ")", "\n", "return", "err", "==", "state", ".", "ErrNoBackingVolume", ",", "nil", "\n", "}", ")", "\n", "}" ]

[ "WatchModelManagedFilesystems", "returns", "a", "strings", "watcher", "that", "reports", "model", "-", "scoped", "filesystems", "that", "have", "no", "backing", "volume", ".", "Volume", "-", "backed", "filesystems", "are", "always", "managed", "by", "the", "host", "to", "which", "they", "are", "attached", "." ]

[ "func", "(", "fw", "Watchers", ")", "WatchUnitManagedFilesystems", "(", "app", "names", ".", "ApplicationTag", ")", "state", ".", "StringsWatcher", "{", "w", ":=", "&", "hostFilesystemsWatcher", "{", "stringsWatcherBase", ":", "stringsWatcherBase", "{", "out", ":", "make", "(", "chan", "[", "]", "string", ")", "}", ",", "backend", ":", "fw", ".", "Backend", ",", "changes", ":", "set", ".", "NewStrings", "(", ")", ",", "hostFilesystems", ":", "fw", ".", "Backend", ".", "WatchUnitFilesystems", "(", "app", ")", ",", "modelFilesystems", ":", "fw", ".", "Backend", ".", "WatchModelFilesystems", "(", ")", ",", "modelVolumeAttachments", ":", "fw", ".", "Backend", ".", "WatchModelVolumeAttachments", "(", ")", ",", "modelVolumesAttached", ":", "names", ".", "NewSet", "(", ")", ",", "modelVolumeFilesystems", ":", "make", "(", "map", "[", "names", ".", "VolumeTag", "]", "names", ".", "FilesystemTag", ")", ",", "hostMatch", ":", "func", "(", "tag", "names", ".", "Tag", ")", "(", "bool", ",", "error", ")", "{", "entity", ",", "err", ":=", "names", ".", "UnitApplication", "(", "tag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "app", ".", "Id", "(", ")", "==", "entity", ",", "nil", "\n", "}", ",", "}", "\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "defer", "watcher", ".", "Stop", "(", "w", ".", "hostFilesystems", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelFilesystems", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelVolumeAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "return", "w", ".", "loop", "(", ")", "\n", "}", ")", "\n", "return", "w", "\n", "}" ]

[ "WatchUnitManagedFilesystems", "returns", "a", "strings", "watcher", "that", "reports", "both", "unit", "-", "scoped", "filesystems", "and", "model", "-", "scoped", "volume", "-", "backed", "filesystems", "that", "are", "attached", "to", "units", "of", "the", "specified", "application", "." ]

[ "func", "(", "fw", "Watchers", ")", "WatchMachineManagedFilesystems", "(", "m", "names", ".", "MachineTag", ")", "state", ".", "StringsWatcher", "{", "w", ":=", "&", "hostFilesystemsWatcher", "{", "stringsWatcherBase", ":", "stringsWatcherBase", "{", "out", ":", "make", "(", "chan", "[", "]", "string", ")", "}", ",", "backend", ":", "fw", ".", "Backend", ",", "changes", ":", "set", ".", "NewStrings", "(", ")", ",", "hostFilesystems", ":", "fw", ".", "Backend", ".", "WatchMachineFilesystems", "(", "m", ")", ",", "modelFilesystems", ":", "fw", ".", "Backend", ".", "WatchModelFilesystems", "(", ")", ",", "modelVolumeAttachments", ":", "fw", ".", "Backend", ".", "WatchModelVolumeAttachments", "(", ")", ",", "modelVolumesAttached", ":", "names", ".", "NewSet", "(", ")", ",", "modelVolumeFilesystems", ":", "make", "(", "map", "[", "names", ".", "VolumeTag", "]", "names", ".", "FilesystemTag", ")", ",", "hostMatch", ":", "func", "(", "tag", "names", ".", "Tag", ")", "(", "bool", ",", "error", ")", "{", "return", "tag", "==", "m", ",", "nil", "\n", "}", ",", "}", "\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "defer", "watcher", ".", "Stop", "(", "w", ".", "hostFilesystems", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelFilesystems", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelVolumeAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "return", "w", ".", "loop", "(", ")", "\n", "}", ")", "\n", "return", "w", "\n", "}" ]

[ "WatchMachineManagedFilesystems", "returns", "a", "strings", "watcher", "that", "reports", "both", "machine", "-", "scoped", "filesystems", "and", "model", "-", "scoped", "volume", "-", "backed", "filesystems", "that", "are", "attached", "to", "the", "specified", "machine", "." ]

[ "func", "(", "fw", "Watchers", ")", "WatchModelManagedFilesystemAttachments", "(", ")", "state", ".", "StringsWatcher", "{", "return", "newFilteredStringsWatcher", "(", "fw", ".", "Backend", ".", "WatchModelFilesystemAttachments", "(", ")", ",", "func", "(", "id", "string", ")", "(", "bool", ",", "error", ")", "{", "_", ",", "filesystemTag", ",", "err", ":=", "state", ".", "ParseFilesystemAttachmentId", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "f", ",", "err", ":=", "fw", ".", "Backend", ".", "Filesystem", "(", "filesystemTag", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "false", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "f", ".", "Volume", "(", ")", "\n", "return", "err", "==", "state", ".", "ErrNoBackingVolume", ",", "nil", "\n", "}", ")", "\n", "}" ]

[ "WatchModelManagedFilesystemAttachments", "returns", "a", "strings", "watcher", "that", "reports", "lifecycle", "changes", "to", "attachments", "of", "model", "-", "scoped", "filesystem", "that", "have", "no", "backing", "volume", ".", "Volume", "-", "backed", "filesystems", "are", "always", "managed", "by", "the", "host", "to", "which", "they", "are", "attached", "." ]

[ "func", "(", "fw", "Watchers", ")", "WatchMachineManagedFilesystemAttachments", "(", "m", "names", ".", "MachineTag", ")", "state", ".", "StringsWatcher", "{", "w", ":=", "&", "hostFilesystemAttachmentsWatcher", "{", "stringsWatcherBase", ":", "stringsWatcherBase", "{", "out", ":", "make", "(", "chan", "[", "]", "string", ")", "}", ",", "backend", ":", "fw", ".", "Backend", ",", "changes", ":", "set", ".", "NewStrings", "(", ")", ",", "hostFilesystemAttachments", ":", "fw", ".", "Backend", ".", "WatchMachineFilesystemAttachments", "(", "m", ")", ",", "modelFilesystemAttachments", ":", "fw", ".", "Backend", ".", "WatchModelFilesystemAttachments", "(", ")", ",", "modelVolumeAttachments", ":", "fw", ".", "Backend", ".", "WatchModelVolumeAttachments", "(", ")", ",", "modelVolumesAttached", ":", "names", ".", "NewSet", "(", ")", ",", "modelVolumeFilesystemAttachments", ":", "make", "(", "map", "[", "names", ".", "VolumeTag", "]", "string", ")", ",", "hostMatch", ":", "func", "(", "tag", "names", ".", "Tag", ")", "(", "bool", ",", "error", ")", "{", "return", "tag", "==", "m", ",", "nil", "\n", "}", ",", "}", "\n\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "defer", "watcher", ".", "Stop", "(", "w", ".", "hostFilesystemAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelFilesystemAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelVolumeAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "return", "w", ".", "loop", "(", ")", "\n", "}", ")", "\n", "return", "w", "\n", "}" ]

[ "WatchMachineManagedFilesystemAttachments", "returns", "a", "strings", "watcher", "that", "reports", "lifecycle", "changes", "for", "attachments", "to", "both", "machine", "-", "scoped", "filesystems", "and", "model", "-", "scoped", "volume", "-", "backed", "filesystems", "that", "are", "attached", "to", "the", "specified", "machine", "." ]

[ "func", "(", "fw", "Watchers", ")", "WatchUnitManagedFilesystemAttachments", "(", "app", "names", ".", "ApplicationTag", ")", "state", ".", "StringsWatcher", "{", "w", ":=", "&", "hostFilesystemAttachmentsWatcher", "{", "stringsWatcherBase", ":", "stringsWatcherBase", "{", "out", ":", "make", "(", "chan", "[", "]", "string", ")", "}", ",", "backend", ":", "fw", ".", "Backend", ",", "changes", ":", "set", ".", "NewStrings", "(", ")", ",", "hostFilesystemAttachments", ":", "fw", ".", "Backend", ".", "WatchUnitFilesystemAttachments", "(", "app", ")", ",", "modelFilesystemAttachments", ":", "fw", ".", "Backend", ".", "WatchModelFilesystemAttachments", "(", ")", ",", "modelVolumeAttachments", ":", "fw", ".", "Backend", ".", "WatchModelVolumeAttachments", "(", ")", ",", "modelVolumesAttached", ":", "names", ".", "NewSet", "(", ")", ",", "modelVolumeFilesystemAttachments", ":", "make", "(", "map", "[", "names", ".", "VolumeTag", "]", "string", ")", ",", "hostMatch", ":", "func", "(", "tag", "names", ".", "Tag", ")", "(", "bool", ",", "error", ")", "{", "unitApp", ",", "err", ":=", "names", ".", "UnitApplication", "(", "tag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "unitApp", "==", "app", ".", "Id", "(", ")", ",", "nil", "\n", "}", ",", "}", "\n\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "defer", "watcher", ".", "Stop", "(", "w", ".", "hostFilesystemAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelFilesystemAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "defer", "watcher", ".", "Stop", "(", "w", ".", "modelVolumeAttachments", ",", "&", "w", ".", "tomb", ")", "\n", "return", "w", ".", "loop", "(", ")", "\n", "}", ")", "\n", "return", "w", "\n", "}" ]

[ "WatchMachineManagedFilesystemAttachments", "returns", "a", "strings", "watcher", "that", "reports", "lifecycle", "changes", "for", "attachments", "to", "both", "unit", "-", "scoped", "filesystems", "and", "model", "-", "scoped", "volume", "-", "backed", "filesystems", "that", "are", "attached", "to", "units", "of", "the", "specified", "application", "." ]

[ "func", "Manifold", "(", "config", "ManifoldConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "APICallerName", ",", "config", ".", "ClockName", ",", "}", ",", "Start", ":", "func", "(", "context", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "var", "clock", "clock", ".", "Clock", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "ClockName", ",", "&", "clock", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "apiCaller", "base", ".", "APICaller", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "APICallerName", ",", "&", "apiCaller", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "facade", ",", "err", ":=", "config", ".", "NewFacade", "(", "apiCaller", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "worker", ",", "err", ":=", "config", ".", "NewWorker", "(", "charmrevision", ".", "Config", "{", "RevisionUpdater", ":", "facade", ",", "Clock", ":", "clock", ",", "Period", ":", "config", ".", "Period", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "worker", ",", "nil", "\n", "}", ",", "}", "\n", "}" ]

[ "Manifold", "returns", "a", "dependency", ".", "Manifold", "that", "runs", "a", "charm", "revision", "worker", "according", "to", "the", "supplied", "configuration", "." ]

[ "func", "NewAPIFacade", "(", "apiCaller", "base", ".", "APICaller", ")", "(", "Facade", ",", "error", ")", "{", "return", "charmrevisionupdater", ".", "NewState", "(", "apiCaller", ")", ",", "nil", "\n", "}" ]

[ "NewAPIFacade", "returns", "a", "Facade", "backed", "by", "the", "supplied", "APICaller", "." ]

[ "func", "markRegistered", "(", "component", ",", "part", "string", ")", "bool", "{", "parts", ",", "ok", ":=", "registered", "[", "component", "]", "\n", "if", "!", "ok", "{", "parts", "=", "set", ".", "NewStrings", "(", ")", "\n", "registered", "[", "component", "]", "=", "parts", "\n", "}", "\n", "if", "parts", ".", "Contains", "(", "part", ")", "{", "return", "false", "\n", "}", "\n", "parts", ".", "Add", "(", "part", ")", "\n", "return", "true", "\n", "}" ]

[ "markRegistered", "helps", "components", "track", "which", "things", "they", "ve", "registered", ".", "If", "the", "part", "has", "already", "been", "registered", "then", "false", "is", "returned", "indicating", "that", "marking", "failed", ".", "This", "way", "components", "can", "ensure", "a", "part", "is", "registered", "only", "once", "." ]

[ "func", "(", "o", "*", "OracleEnviron", ")", "DeleteMachineVnicSet", "(", "machineId", "string", ")", "error", "{", "if", "err", ":=", "o", ".", "RemoveACLAndRules", "(", "machineId", ")", ";", "err", "!=", "nil", "{", "// A method not allowed error denotes that this feature", "// is not enabled. Probably a trial account, so not really an error", "if", "!", "oci", ".", "IsMethodNotAllowed", "(", "err", ")", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "name", ":=", "o", ".", "client", ".", "ComposeName", "(", "o", ".", "namespace", ".", "Value", "(", "machineId", ")", ")", "\n", "if", "err", ":=", "o", ".", "client", ".", "DeleteVnicSet", "(", "name", ")", ";", "err", "!=", "nil", "{", "if", "!", "oci", ".", "IsNotFound", "(", "err", ")", "&&", "!", "oci", ".", "IsMethodNotAllowed", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteMachineVnicSet", "will", "delete", "the", "machine", "vNIC", "set", "and", "any", "ACLs", "bound", "to", "it", "." ]

[ "func", "HasSupport", "(", ")", "bool", "{", "t", ":=", "os", ".", "HostOS", "(", ")", "\n", "for", "_", ",", "v", ":=", "range", "osSupport", "{", "if", "v", "==", "t", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HasSupport", "returns", "true", "if", "the", "current", "OS", "supports", "LXD", "containers", "by", "default" ]

[ "func", "MaybeNewLocalServer", "(", ")", "(", "*", "Server", ",", "error", ")", "{", "if", "!", "HasSupport", "(", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "svr", ",", "err", ":=", "NewLocalServer", "(", ")", "\n", "return", "svr", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "MaybeNewLocalServer", "returns", "a", "Server", "based", "on", "a", "local", "socket", "connection", "if", "running", "on", "an", "OS", "supporting", "LXD", "containers", "by", "default", ".", "Otherwise", "a", "nil", "server", "is", "returned", "." ]

[ "func", "NewLocalServer", "(", ")", "(", "*", "Server", ",", "error", ")", "{", "cSvr", ",", "err", ":=", "ConnectLocal", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "svr", ",", "err", ":=", "NewServer", "(", "cSvr", ")", "\n", "return", "svr", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "NewLocalServer", "returns", "a", "Server", "based", "on", "a", "local", "socket", "connection", "." ]

[ "func", "NewRemoteServer", "(", "spec", "ServerSpec", ")", "(", "*", "Server", ",", "error", ")", "{", "if", "err", ":=", "spec", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Skip the get, because we know that we're going to request it", "// when calling new server, preventing the double request.", "spec", ".", "connectionArgs", ".", "SkipGetServer", "=", "true", "\n", "cSvr", ",", "err", ":=", "ConnectRemote", "(", "spec", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "svr", ",", "err", ":=", "NewServer", "(", "cSvr", ")", "\n", "return", "svr", ",", "err", "\n", "}" ]

[ "NewRemoteServer", "returns", "a", "Server", "based", "on", "a", "remote", "connection", "." ]

[ "func", "NewServer", "(", "svr", "lxd", ".", "ContainerServer", ")", "(", "*", "Server", ",", "error", ")", "{", "info", ",", "_", ",", "err", ":=", "svr", ".", "GetServer", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "apiExt", ":=", "info", ".", "APIExtensions", "\n\n", "name", ":=", "info", ".", "Environment", ".", "ServerName", "\n", "clustered", ":=", "info", ".", "Environment", ".", "ServerClustered", "\n", "if", "name", "==", "\"", "\"", "&&", "!", "clustered", "{", "// If the name is set to empty and clustering is false, then it's highly", "// likely that we're on an older version of LXD. So in that case we", "// need to set the name to something and internally LXD sets this type", "// of node to \"none\".", "// LP:#1786309", "name", "=", "\"", "\"", "\n", "}", "\n", "serverCertificate", ":=", "info", ".", "Environment", ".", "Certificate", "\n", "hostArch", ":=", "arch", ".", "NormaliseArch", "(", "info", ".", "Environment", ".", "KernelArchitecture", ")", "\n\n", "return", "&", "Server", "{", "ContainerServer", ":", "svr", ",", "name", ":", "name", ",", "clustered", ":", "clustered", ",", "serverCertificate", ":", "serverCertificate", ",", "hostArch", ":", "hostArch", ",", "networkAPISupport", ":", "shared", ".", "StringInSlice", "(", "\"", "\"", ",", "apiExt", ")", ",", "clusterAPISupport", ":", "shared", ".", "StringInSlice", "(", "\"", "\"", ",", "apiExt", ")", ",", "storageAPISupport", ":", "shared", ".", "StringInSlice", "(", "\"", "\"", ",", "apiExt", ")", ",", "serverVersion", ":", "info", ".", "Environment", ".", "ServerVersion", ",", "clock", ":", "clock", ".", "WallClock", ",", "}", ",", "nil", "\n", "}" ]

[ "NewServer", "builds", "and", "returns", "a", "Server", "for", "high", "-", "level", "interaction", "with", "the", "input", "LXD", "container", "server", "." ]

[ "func", "(", "s", "*", "Server", ")", "UpdateServerConfig", "(", "cfg", "map", "[", "string", "]", "string", ")", "error", "{", "svr", ",", "eTag", ",", "err", ":=", "s", ".", "GetServer", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "svr", ".", "Config", "==", "nil", "{", "svr", ".", "Config", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "cfg", "{", "svr", ".", "Config", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "s", ".", "UpdateServer", "(", "svr", ".", "Writable", "(", ")", ",", "eTag", ")", ")", "\n", "}" ]

[ "UpdateServerConfig", "updates", "the", "server", "configuration", "with", "the", "input", "values", "." ]

[ "func", "(", "s", "*", "Server", ")", "UpdateContainerConfig", "(", "name", "string", ",", "cfg", "map", "[", "string", "]", "string", ")", "error", "{", "container", ",", "eTag", ",", "err", ":=", "s", ".", "GetContainer", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "container", ".", "Config", "==", "nil", "{", "container", ".", "Config", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "cfg", "{", "container", ".", "Config", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "resp", ",", "err", ":=", "s", ".", "UpdateContainer", "(", "name", ",", "container", ".", "Writable", "(", ")", ",", "eTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "resp", ".", "Wait", "(", ")", ")", "\n", "}" ]

[ "UpdateContainerConfig", "updates", "the", "configuration", "for", "the", "container", "with", "the", "input", "name", "using", "the", "input", "values", "." ]

[ "func", "(", "s", "*", "Server", ")", "GetContainerProfiles", "(", "name", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "container", ",", "_", ",", "err", ":=", "s", ".", "GetContainer", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "]", "string", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "container", ".", "Profiles", ",", "nil", "\n", "}" ]

[ "GetContainerProfiles", "returns", "the", "list", "of", "profiles", "that", "are", "assocated", "with", "a", "container", "." ]

[ "func", "(", "s", "*", "Server", ")", "CreateClientCertificate", "(", "cert", "*", "Certificate", ")", "error", "{", "req", ",", "err", ":=", "cert", ".", "AsCreateRequest", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "s", ".", "CreateCertificate", "(", "req", ")", ")", "\n", "}" ]

[ "CreateClientCertificate", "adds", "the", "input", "certificate", "to", "the", "server", "indicating", "that", "is", "for", "use", "in", "client", "communication", "." ]

[ "func", "(", "s", "*", "Server", ")", "HasProfile", "(", "name", "string", ")", "(", "bool", ",", "error", ")", "{", "profiles", ",", "err", ":=", "s", ".", "GetProfileNames", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "profile", ":=", "range", "profiles", "{", "if", "profile", "==", "name", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "HasProfile", "interrogates", "the", "known", "profile", "names", "and", "returns", "a", "boolean", "indicating", "whether", "a", "profile", "with", "the", "input", "name", "exists", "." ]

[ "func", "(", "s", "*", "Server", ")", "CreateProfileWithConfig", "(", "name", "string", ",", "cfg", "map", "[", "string", "]", "string", ")", "error", "{", "req", ":=", "api", ".", "ProfilesPost", "{", "Name", ":", "name", ",", "ProfilePut", ":", "api", ".", "ProfilePut", "{", "Config", ":", "cfg", ",", "}", ",", "}", "\n", "return", "errors", ".", "Trace", "(", "s", ".", "CreateProfile", "(", "req", ")", ")", "\n", "}" ]

[ "CreateProfileWithConfig", "creates", "a", "new", "profile", "with", "the", "input", "name", "and", "config", "." ]

[ "func", "NewFacadeV1", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "ClientV1", ",", "error", ")", "{", "client", ",", "err", ":=", "newFacade", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "ClientV1", "{", "client", "}", ",", "nil", "\n", "}" ]

[ "NewFacadeV1", "creates", "a", "version", "1", "Client", "facade", "to", "handle", "API", "requests", "." ]

[ "func", "NewClient", "(", "backend", "Backend", ",", "pool", "Pool", ",", "modelConfigAPI", "*", "modelconfig", ".", "ModelConfigAPIV1", ",", "resources", "facade", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ",", "presence", "facade", ".", "Presence", ",", "statusSetter", "*", "common", ".", "StatusSetter", ",", "toolsFinder", "*", "common", ".", "ToolsFinder", ",", "newEnviron", "func", "(", ")", "(", "environs", ".", "BootstrapEnviron", ",", "error", ")", ",", "blockChecker", "*", "common", ".", "BlockChecker", ",", "callCtx", "context", ".", "ProviderCallContext", ",", "leadershipReader", "leadership", ".", "Reader", ",", ")", "(", "*", "Client", ",", "error", ")", "{", "if", "!", "authorizer", ".", "AuthClient", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "client", ":=", "&", "Client", "{", "ModelConfigAPIV1", ":", "modelConfigAPI", ",", "api", ":", "&", "API", "{", "stateAccessor", ":", "backend", ",", "pool", ":", "pool", ",", "auth", ":", "authorizer", ",", "resources", ":", "resources", ",", "presence", ":", "presence", ",", "statusSetter", ":", "statusSetter", ",", "toolsFinder", ":", "toolsFinder", ",", "leadershipReader", ":", "leadershipReader", ",", "}", ",", "newEnviron", ":", "newEnviron", ",", "check", ":", "blockChecker", ",", "callContext", ":", "callCtx", ",", "}", "\n", "return", "client", ",", "nil", "\n", "}" ]

[ "NewClient", "creates", "a", "new", "instance", "of", "the", "Client", "Facade", "." ]

[ "func", "(", "c", "*", "Client", ")", "WatchAll", "(", ")", "(", "params", ".", "AllWatcherId", ",", "error", ")", "{", "if", "err", ":=", "c", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "AllWatcherId", "{", "}", ",", "err", "\n", "}", "\n", "model", ",", "err", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "AllWatcherId", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Since we know this is a user tag (because AuthClient is true),", "// we just do the type assertion to the UserTag.", "apiUser", ",", "_", ":=", "c", ".", "api", ".", "auth", ".", "GetAuthTag", "(", ")", ".", "(", "names", ".", "UserTag", ")", "\n", "isAdmin", ",", "err", ":=", "common", ".", "HasModelAdmin", "(", "c", ".", "api", ".", "auth", ",", "apiUser", ",", "c", ".", "api", ".", "stateAccessor", ".", "ControllerTag", "(", ")", ",", "model", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "AllWatcherId", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "watchParams", ":=", "state", ".", "WatchParams", "{", "IncludeOffers", ":", "isAdmin", "}", "\n\n", "w", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Watch", "(", "watchParams", ")", "\n", "return", "params", ".", "AllWatcherId", "{", "AllWatcherId", ":", "c", ".", "api", ".", "resources", ".", "Register", "(", "w", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "WatchAll", "initiates", "a", "watcher", "for", "entities", "in", "the", "connected", "model", "." ]

[ "func", "(", "c", "*", "Client", ")", "Resolved", "(", "p", "params", ".", "Resolved", ")", "error", "{", "if", "err", ":=", "c", ".", "checkCanWrite", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "c", ".", "check", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "unit", ",", "err", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Unit", "(", "p", ".", "UnitName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "unit", ".", "Resolve", "(", "p", ".", "Retry", ")", "\n", "}" ]

[ "Resolved", "implements", "the", "server", "side", "of", "Client", ".", "Resolved", "." ]

[ "func", "(", "c", "*", "Client", ")", "PublicAddress", "(", "p", "params", ".", "PublicAddress", ")", "(", "results", "params", ".", "PublicAddressResults", ",", "err", "error", ")", "{", "if", "err", ":=", "c", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "PublicAddressResults", "{", "}", ",", "err", "\n", "}", "\n\n", "switch", "{", "case", "names", ".", "IsValidMachine", "(", "p", ".", "Target", ")", ":", "machine", ",", "err", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Machine", "(", "p", ".", "Target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "results", ",", "err", "\n", "}", "\n", "addr", ",", "err", ":=", "machine", ".", "PublicAddress", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "machine", ")", "\n", "}", "\n", "return", "params", ".", "PublicAddressResults", "{", "PublicAddress", ":", "addr", ".", "Value", "}", ",", "nil", "\n\n", "case", "names", ".", "IsValidUnit", "(", "p", ".", "Target", ")", ":", "unit", ",", "err", ":=", "c", ".", "api", ".", "stateAccessor", ".", "Unit", "(", "p", ".", "Target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "results", ",", "err", "\n", "}", "\n", "addr", ",", "err", ":=", "unit", ".", "PublicAddress", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "unit", ")", "\n", "}", "\n", "return", "params", ".", "PublicAddressResults", "{", "PublicAddress", ":", "addr", ".", "Value", "}", ",", "nil", "\n", "}", "\n", "return", "results", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "Target", ")", "\n", "}" ]

[ "PublicAddress", "implements", "the", "server", "side", "of", "Client", ".", "PublicAddress", "." ]