Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "(", "d", "*", "manifestDeployer", ")", "startDeploy", "(", ")", "error", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "d", ".", "staged", ".", "url", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "d", ".", "charmPath", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "WriteCharmURL", "(", "d", ".", "CharmPath", "(", "deployingURLPath", ")", ",", "d", ".", "staged", ".", "url", ")", "\n", "}" ]

[ "startDeploy", "persists", "the", "fact", "that", "we", "ve", "started", "deploying", "the", "staged", "bundle", "." ]

[ "func", "(", "d", "*", "manifestDeployer", ")", "removeDiff", "(", "oldManifest", ",", "newManifest", "set", ".", "Strings", ")", "error", "{", "diff", ":=", "oldManifest", ".", "Difference", "(", "newManifest", ")", "\n", "for", "_", ",", "path", ":=", "range", "diff", ".", "SortedValues", "(", ")", "{", "fullPath", ":=", "filepath", ".", "Join", "(", "d", ".", "charmPath", ",", "filepath", ".", "FromSlash", "(", "path", ")", ")", "\n", "if", "err", ":=", "os", ".", "RemoveAll", "(", "fullPath", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "removeDiff", "removes", "every", "path", "in", "oldManifest", "that", "is", "not", "present", "in", "newManifest", "." ]

[ "func", "(", "d", "*", "manifestDeployer", ")", "finishDeploy", "(", ")", "error", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "d", ".", "staged", ".", "url", ")", "\n", "oldPath", ":=", "d", ".", "CharmPath", "(", "deployingURLPath", ")", "\n", "newPath", ":=", "d", ".", "CharmPath", "(", "CharmURLPath", ")", "\n", "return", "utils", ".", "ReplaceFile", "(", "oldPath", ",", "newPath", ")", "\n", "}" ]

[ "finishDeploy", "persists", "the", "fact", "that", "we", "ve", "finished", "deploying", "the", "staged", "bundle", "." ]

[ "func", "(", "d", "*", "manifestDeployer", ")", "storeManifest", "(", "url", "*", "charm", ".", "URL", ",", "manifest", "set", ".", "Strings", ")", "error", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "d", ".", "DataPath", "(", "manifestsDataPath", ")", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "name", ":=", "charm", ".", "Quote", "(", "url", ".", "String", "(", ")", ")", "\n", "path", ":=", "filepath", ".", "Join", "(", "d", ".", "DataPath", "(", "manifestsDataPath", ")", ",", "name", ")", "\n", "return", "utils", ".", "WriteYaml", "(", "path", ",", "manifest", ".", "SortedValues", "(", ")", ")", "\n", "}" ]

[ "storeManifest", "stores", "into", "dataPath", "the", "supplied", "manifest", "for", "the", "supplied", "charm", "." ]

[ "func", "(", "d", "*", "manifestDeployer", ")", "loadManifest", "(", "urlFilePath", "string", ")", "(", "*", "charm", ".", "URL", ",", "set", ".", "Strings", ",", "error", ")", "{", "url", ",", "err", ":=", "ReadCharmURL", "(", "d", ".", "CharmPath", "(", "urlFilePath", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "name", ":=", "charm", ".", "Quote", "(", "url", ".", "String", "(", ")", ")", "\n", "path", ":=", "filepath", ".", "Join", "(", "d", ".", "DataPath", "(", "manifestsDataPath", ")", ",", "name", ")", "\n", "manifest", ":=", "[", "]", "string", "{", "}", "\n", "err", "=", "utils", ".", "ReadYaml", "(", "path", ",", "&", "manifest", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "path", ",", "url", ")", "\n", "err", "=", "nil", "\n", "}", "\n", "return", "url", ",", "set", ".", "NewStrings", "(", "manifest", "...", ")", ",", "err", "\n", "}" ]

[ "loadManifest", "loads", "from", "dataPath", "the", "manifest", "for", "the", "charm", "identified", "by", "the", "identity", "file", "at", "the", "supplied", "path", "within", "the", "charm", "directory", "." ]

[ "func", "(", "d", "*", "manifestDeployer", ")", "CharmPath", "(", "path", "string", ")", "string", "{", "return", "filepath", ".", "Join", "(", "d", ".", "charmPath", ",", "path", ")", "\n", "}" ]

[ "CharmPath", "returns", "the", "supplied", "path", "joined", "to", "the", "ManifestDeployer", "s", "charm", "directory", "." ]

[ "func", "(", "d", "*", "manifestDeployer", ")", "DataPath", "(", "path", "string", ")", "string", "{", "return", "filepath", ".", "Join", "(", "d", ".", "dataPath", ",", "path", ")", "\n", "}" ]

[ "DataPath", "returns", "the", "supplied", "path", "joined", "to", "the", "ManifestDeployer", "s", "data", "directory", "." ]

[ "func", "manifestDeployError", "(", "err", "*", "error", ",", "upgrading", "bool", ")", "{", "if", "*", "err", "!=", "nil", "{", "if", "upgrading", "{", "// We now treat any failure to overwrite the charm -- or otherwise", "// manipulate the charm directory -- as a conflict, because it's", "// actually plausible for a user (or at least a charm author, who", "// is the real audience for this case) to get in there and fix it.", "logger", ".", "Errorf", "(", "\"", "\"", ",", "*", "err", ")", "\n", "*", "err", "=", "ErrConflict", "\n", "}", "else", "{", "// ...but if we can't install at all, we just fail out as the old", "// gitDeployer did, because I'm not willing to mess around with", "// the uniter to enable ErrConflict handling on install. We've", "// never heard of it actually happening, so this is probably not", "// a big deal.", "*", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "manifestDeployError", "annotates", "or", "replaces", "the", "supplied", "error", "according", "to", "whether", "or", "not", "an", "upgrade", "operation", "is", "in", "play", ".", "It", "was", "extracted", "from", "Deploy", "to", "aid", "that", "method", "s", "readability", "." ]

[ "func", "NewOfferCommand", "(", ")", "cmd", ".", "Command", "{", "offerCmd", ":=", "&", "offerCommand", "{", "}", "\n", "offerCmd", ".", "newAPIFunc", "=", "func", "(", ")", "(", "OfferAPI", ",", "error", ")", "{", "return", "offerCmd", ".", "NewApplicationOffersAPI", "(", ")", "\n", "}", "\n", "offerCmd", ".", "refreshModels", "=", "offerCmd", ".", "ControllerCommandBase", ".", "RefreshModels", "\n", "return", "modelcmd", ".", "WrapController", "(", "offerCmd", ")", "\n", "}" ]

[ "NewOfferCommand", "constructs", "commands", "that", "enables", "endpoints", "for", "export", "." ]

[ "func", "(", "st", "State", ")", "validate", "(", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ")", "\n", "hasHook", ":=", "st", ".", "Hook", "!=", "nil", "\n", "hasActionId", ":=", "st", ".", "ActionId", "!=", "nil", "\n", "hasCharm", ":=", "st", ".", "CharmURL", "!=", "nil", "\n", "switch", "st", ".", "Kind", "{", "case", "Install", ":", "if", "st", ".", "Installed", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "fallthrough", "\n", "case", "Upgrade", ":", "switch", "{", "case", "!", "hasCharm", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "hasActionId", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "RunAction", ":", "switch", "{", "case", "!", "hasActionId", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "hasCharm", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "RunHook", ":", "switch", "{", "case", "!", "hasHook", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "hasCharm", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "hasActionId", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "Continue", ":", "// TODO(jw4) LP-1438489", "// ModeContinue should no longer have a Hook, but until the upgrade is", "// fixed we can't fail the validation if it does.", "if", "hasHook", "{", "logger", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "switch", "{", "case", "hasCharm", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "hasActionId", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "st", ".", "Kind", ")", "\n", "}", "\n", "switch", "st", ".", "Step", "{", "case", "Queued", ",", "Pending", ",", "Done", ":", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "st", ".", "Step", ")", "\n", "}", "\n", "if", "hasHook", "{", "return", "st", ".", "Hook", ".", "Validate", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "validate", "returns", "an", "error", "if", "the", "state", "violates", "expectations", "." ]

[ "func", "keysEqual", "(", "a", ",", "b", "[", "]", "string", ")", "bool", "{", "if", "len", "(", "a", ")", "!=", "len", "(", "b", ")", "{", "return", "false", "\n", "}", "\n", "a", "=", "a", "[", ":", "]", "\n", "b", "=", "b", "[", ":", "]", "\n", "sort", ".", "Strings", "(", "a", ")", "\n", "sort", ".", "Strings", "(", "b", ")", "\n", "for", "i", ":=", "range", "a", "{", "if", "a", "[", "i", "]", "!=", "b", "[", "i", "]", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "keysEqual", "checks", "if", "the", "ssh", "host", "keys", "are", "the", "same", "between", "two", "sets", ".", "we", "shouldn", "t", "care", "about", "the", "order", "of", "the", "keys", "." ]

[ "func", "(", "st", "*", "State", ")", "SetSSHHostKeys", "(", "tag", "names", ".", "MachineTag", ",", "keys", "SSHHostKeys", ")", "error", "{", "coll", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "sshHostKeysC", ")", "\n", "defer", "closer", "(", ")", "\n", "id", ":=", "machineGlobalKey", "(", "tag", ".", "Id", "(", ")", ")", "\n", "doc", ":=", "sshHostKeysDoc", "{", "Keys", ":", "keys", ",", "}", "\n", "var", "dbDoc", "sshHostKeysDoc", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "err", ":=", "coll", ".", "FindId", "(", "id", ")", ".", "One", "(", "&", "dbDoc", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "sshHostKeysC", ",", "Id", ":", "id", ",", "Insert", ":", "doc", ",", "}", "}", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "if", "keysEqual", "(", "dbDoc", ".", "Keys", ",", "keys", ")", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "sshHostKeysC", ",", "Id", ":", "id", ",", "Update", ":", "bson", ".", "M", "{", "\"", "\"", ":", "doc", "}", ",", "}", "}", ",", "nil", "\n", "}", "\n\n", "if", "err", ":=", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetSSHHostKeys", "updates", "the", "stored", "SSH", "host", "keys", "for", "an", "entity", ".", "See", "the", "note", "for", "GetSSHHostKeys", "regarding", "supported", "entities", "." ]

[ "func", "removeSSHHostKeyOp", "(", "globalKey", "string", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "sshHostKeysC", ",", "Id", ":", "globalKey", ",", "Remove", ":", "true", ",", "}", "\n", "}" ]

[ "removeSSHHostKeyOp", "returns", "the", "operation", "needed", "to", "remove", "the", "SSH", "host", "key", "document", "associated", "with", "the", "given", "globalKey", "." ]

[ "func", "NewFacade", "(", "backend", "Backend", ",", "res", "facade", ".", "Resources", ",", "auth", "facade", ".", "Authorizer", ")", "(", "*", "Facade", ",", "error", ")", "{", "if", "!", "auth", ".", "AuthController", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "&", "Facade", "{", "backend", ":", "backend", ",", "resources", ":", "res", ",", "}", ",", "nil", "\n", "}" ]

[ "NewFacade", "creates", "a", "new", "authorized", "Facade", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "Watch", "(", ")", "(", "params", ".", "StringsWatchResult", ",", "error", ")", "{", "watch", ":=", "facade", ".", "backend", ".", "WatchScaledServices", "(", ")", "\n", "if", "changes", ",", "ok", ":=", "<-", "watch", ".", "Changes", "(", ")", ";", "ok", "{", "id", ":=", "facade", ".", "resources", ".", "Register", "(", "watch", ")", "\n", "return", "params", ".", "StringsWatchResult", "{", "StringsWatcherId", ":", "id", ",", "Changes", ":", "changes", ",", "}", ",", "nil", "\n", "}", "\n", "return", "params", ".", "StringsWatchResult", "{", "}", ",", "watcher", ".", "EnsureErr", "(", "watch", ")", "\n", "}" ]

[ "Watch", "returns", "a", "watcher", "that", "sends", "the", "names", "of", "services", "whose", "unit", "count", "may", "be", "below", "their", "configured", "minimum", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "Rescale", "(", "args", "params", ".", "Entities", ")", "params", ".", "ErrorResults", "{", "result", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "err", ":=", "facade", ".", "rescaleOne", "(", "entity", ".", "Tag", ")", "\n", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Rescale", "causes", "any", "supplied", "services", "to", "be", "scaled", "up", "to", "their", "minimum", "size", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "rescaleOne", "(", "tagString", "string", ")", "error", "{", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "tagString", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ApplicationTag", ",", "ok", ":=", "tag", ".", "(", "names", ".", "ApplicationTag", ")", "\n", "if", "!", "ok", "{", "return", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "facade", ".", "backend", ".", "RescaleService", "(", "ApplicationTag", ".", "Id", "(", ")", ")", "\n", "}" ]

[ "rescaleOne", "scales", "up", "the", "supplied", "service", "if", "necessary", ";", "or", "returns", "a", "suitable", "error", "." ]

[ "func", "NewTLSConfig", "(", "st", "*", "state", ".", "State", ",", "getCertificate", "func", "(", ")", "*", "tls", ".", "Certificate", ")", "(", "*", "tls", ".", "Config", ",", "error", ")", "{", "controllerConfig", ",", "err", ":=", "st", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "newTLSConfig", "(", "controllerConfig", ".", "AutocertDNSName", "(", ")", ",", "controllerConfig", ".", "AutocertURL", "(", ")", ",", "st", ".", "AutocertCache", "(", ")", ",", "getCertificate", ",", ")", ",", "nil", "\n", "}" ]

[ "NewTLSConfig", "returns", "the", "TLS", "configuration", "for", "the", "HTTP", "server", "to", "use", "based", "on", "controller", "configuration", "stored", "in", "the", "state", "database", "." ]

[ "func", "(", "c", "*", "Client", ")", "Create", "(", "notes", "string", ",", "keepCopy", ",", "noDownload", "bool", ")", "(", "*", "params", ".", "BackupsMetadataResult", ",", "error", ")", "{", "var", "result", "params", ".", "BackupsMetadataResult", "\n", "args", ":=", "params", ".", "BackupsCreateArgs", "{", "Notes", ":", "notes", ",", "KeepCopy", ":", "keepCopy", ",", "NoDownload", ":", "noDownload", ",", "}", "\n\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "result", ",", "nil", "\n", "}" ]

[ "Create", "sends", "a", "request", "to", "create", "a", "backup", "of", "juju", "s", "state", ".", "It", "returns", "the", "metadata", "associated", "with", "the", "resulting", "backup", "and", "a", "filename", "for", "download", "." ]

[ "func", "NewBundlesDir", "(", "path", "string", ",", "dlr", "Downloader", ")", "*", "BundlesDir", "{", "if", "dlr", "==", "nil", "{", "dlr", "=", "downloader", ".", "New", "(", "downloader", ".", "NewArgs", "{", "HostnameVerification", ":", "utils", ".", "NoVerifySSLHostnames", ",", "}", ")", "\n", "}", "\n", "return", "&", "BundlesDir", "{", "path", ":", "path", ",", "downloader", ":", "dlr", ",", "}", "\n", "}" ]

[ "NewBundlesDir", "returns", "a", "new", "BundlesDir", "which", "uses", "path", "for", "storage", "." ]

[ "func", "(", "d", "*", "BundlesDir", ")", "Read", "(", "info", "BundleInfo", ",", "abort", "<-", "chan", "struct", "{", "}", ")", "(", "Bundle", ",", "error", ")", "{", "path", ":=", "d", ".", "bundlePath", "(", "info", ")", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "err", "!=", "nil", "{", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "download", "(", "info", ",", "path", ",", "abort", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "charm", ".", "ReadCharmArchive", "(", "path", ")", "\n", "}" ]

[ "Read", "returns", "a", "charm", "bundle", "from", "the", "directory", ".", "If", "no", "bundle", "exists", "yet", "one", "will", "be", "downloaded", "and", "validated", "and", "copied", "into", "the", "directory", "before", "being", "returned", ".", "Downloads", "will", "be", "aborted", "if", "a", "value", "is", "received", "on", "abort", "." ]

[ "func", "(", "d", "*", "BundlesDir", ")", "download", "(", "info", "BundleInfo", ",", "target", "string", ",", "abort", "<-", "chan", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "// First download...", "curl", ",", "err", ":=", "url", ".", "Parse", "(", "info", ".", "URL", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "expectedSha256", ",", "err", ":=", "info", ".", "ArchiveSha256", "(", ")", "\n", "req", ":=", "downloader", ".", "Request", "{", "URL", ":", "curl", ",", "TargetDir", ":", "downloadsPath", "(", "d", ".", "path", ")", ",", "Verify", ":", "downloader", ".", "NewSha256Verifier", "(", "expectedSha256", ")", ",", "Abort", ":", "abort", ",", "}", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "info", ".", "URL", "(", ")", ")", "\n", "filename", ",", "err", ":=", "d", ".", "downloader", ".", "Download", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "info", ".", "URL", "(", ")", ")", "\n", "}", "\n", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "target", ",", "filename", ")", "\n\n", "// ...then move the right location.", "if", "err", ":=", "os", ".", "MkdirAll", "(", "d", ".", "path", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "os", ".", "Rename", "(", "filename", ",", "target", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "download", "fetches", "the", "supplied", "charm", "and", "checks", "that", "it", "has", "the", "correct", "sha256", "hash", "then", "copies", "it", "into", "the", "directory", ".", "If", "a", "value", "is", "received", "on", "abort", "the", "download", "will", "be", "stopped", "." ]

[ "func", "(", "d", "*", "BundlesDir", ")", "bundlePath", "(", "info", "BundleInfo", ")", "string", "{", "return", "d", ".", "bundleURLPath", "(", "info", ".", "URL", "(", ")", ")", "\n", "}" ]

[ "bundlePath", "returns", "the", "path", "to", "the", "location", "where", "the", "verified", "charm", "bundle", "identified", "by", "info", "will", "be", "or", "has", "been", "saved", "." ]

[ "func", "(", "d", "*", "BundlesDir", ")", "bundleURLPath", "(", "url", "*", "charm", ".", "URL", ")", "string", "{", "return", "path", ".", "Join", "(", "d", ".", "path", ",", "charm", ".", "Quote", "(", "url", ".", "String", "(", ")", ")", ")", "\n", "}" ]

[ "bundleURLPath", "returns", "the", "path", "to", "the", "location", "where", "the", "verified", "charm", "bundle", "identified", "by", "url", "will", "be", "or", "has", "been", "saved", "." ]

[ "func", "ClearDownloads", "(", "bundlesDir", "string", ")", "error", "{", "downloadDir", ":=", "downloadsPath", "(", "bundlesDir", ")", "\n", "err", ":=", "os", ".", "RemoveAll", "(", "downloadDir", ")", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}" ]

[ "ClearDownloads", "removes", "any", "entries", "in", "the", "temporary", "bundle", "download", "directory", ".", "It", "is", "intended", "to", "be", "called", "on", "uniter", "startup", "." ]

[ "func", "formatMetadataTabular", "(", "writer", "io", ".", "Writer", ",", "metadata", "[", "]", "MetadataInfo", ")", "{", "tw", ":=", "output", ".", "TabWriter", "(", "writer", ")", "\n", "print", ":=", "func", "(", "values", "...", "string", ")", "{", "fmt", ".", "Fprintln", "(", "tw", ",", "strings", ".", "Join", "(", "values", ",", "\"", "\\t", "\"", ")", ")", "\n", "}", "\n", "print", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "for", "_", ",", "m", ":=", "range", "metadata", "{", "print", "(", "m", ".", "Source", ",", "m", ".", "Series", ",", "m", ".", "Arch", ",", "m", ".", "Region", ",", "m", ".", "ImageId", ",", "m", ".", "Stream", ",", "m", ".", "VirtType", ",", "m", ".", "RootStorageType", ")", "\n", "}", "\n", "tw", ".", "Flush", "(", ")", "\n", "}" ]

[ "formatMetadataTabular", "writes", "a", "tabular", "summary", "of", "cloud", "image", "metadata", "." ]

[ "func", "NewAgentAPIV2", "(", "st", "*", "state", ".", "State", ",", "resources", "facade", ".", "Resources", ",", "auth", "facade", ".", "Authorizer", ")", "(", "*", "AgentAPIV2", ",", "error", ")", "{", "// Agents are defined to be any user that's not a client user.", "if", "!", "auth", ".", "AuthMachineAgent", "(", ")", "&&", "!", "auth", ".", "AuthUnitAgent", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "getCanChange", ":=", "func", "(", ")", "(", "common", ".", "AuthFunc", ",", "error", ")", "{", "return", "auth", ".", "AuthOwner", ",", "nil", "\n", "}", "\n\n", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "AgentAPIV2", "{", "PasswordChanger", ":", "common", ".", "NewPasswordChanger", "(", "st", ",", "getCanChange", ")", ",", "RebootFlagClearer", ":", "common", ".", "NewRebootFlagClearer", "(", "st", ",", "getCanChange", ")", ",", "ModelWatcher", ":", "common", ".", "NewModelWatcher", "(", "model", ",", "resources", ",", "auth", ")", ",", "ControllerConfigAPI", ":", "common", ".", "NewStateControllerConfig", "(", "st", ")", ",", "CloudSpecAPI", ":", "cloudspec", ".", "NewCloudSpec", "(", "resources", ",", "cloudspec", ".", "MakeCloudSpecGetterForModel", "(", "st", ")", ",", "cloudspec", ".", "MakeCloudSpecWatcherForModel", "(", "st", ")", ",", "common", ".", "AuthFuncForTag", "(", "model", ".", "ModelTag", "(", ")", ")", ",", ")", ",", "st", ":", "st", ",", "auth", ":", "auth", ",", "resources", ":", "resources", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAgentAPIV2", "returns", "an", "object", "implementing", "version", "2", "of", "the", "Agent", "API", "with", "the", "given", "authorizer", "representing", "the", "currently", "logged", "in", "client", "." ]

[ "func", "(", "api", "*", "AgentAPIV2", ")", "WatchCredentials", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "NotifyWatchResults", ",", "error", ")", "{", "if", "!", "api", ".", "auth", ".", "AuthController", "(", ")", "{", "return", "params", ".", "NotifyWatchResults", "{", "}", ",", "common", ".", "ErrPerm", "\n", "}", "\n\n", "results", ":=", "params", ".", "NotifyWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "NotifyWatchResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "credentialTag", ",", "err", ":=", "names", ".", "ParseCloudCredentialTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "watch", ":=", "api", ".", "st", ".", "WatchCredential", "(", "credentialTag", ")", "\n", "// Consume the initial event. Technically, API calls to Watch", "// 'transmit' the initial event in the Watch response. But", "// NotifyWatchers have no state to transmit.", "if", "_", ",", "ok", ":=", "<-", "watch", ".", "Changes", "(", ")", ";", "ok", "{", "results", ".", "Results", "[", "i", "]", ".", "NotifyWatcherId", "=", "api", ".", "resources", ".", "Register", "(", "watch", ")", "\n", "}", "else", "{", "err", "=", "watcher", ".", "EnsureErr", "(", "watch", ")", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "WatchCredentials", "watches", "for", "changes", "to", "the", "specified", "credentials", "." ]

[ "func", "NewAuditLogFilter", "(", "log", "auditlog", ".", "AuditLog", ",", "filter", "func", "(", "auditlog", ".", "Request", ")", "bool", ")", "auditlog", ".", "AuditLog", "{", "return", "&", "bufferedLog", "{", "dest", ":", "log", ",", "interesting", ":", "filter", ",", "}", "\n", "}" ]

[ "NewAuditLogFilter", "returns", "an", "auditlog", ".", "AuditLog", "that", "will", "only", "log", "conversations", "to", "the", "underlying", "log", "passed", "in", "if", "they", "include", "a", "request", "that", "satisfies", "the", "filter", "function", "passed", "in", "." ]

[ "func", "(", "l", "*", "bufferedLog", ")", "AddConversation", "(", "c", "auditlog", ".", "Conversation", ")", "error", "{", "l", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "mu", ".", "Unlock", "(", ")", "\n", "// We always buffer the conversation, since we don't know whether", "// it will have any interesting requests yet.", "l", ".", "deferMessage", "(", "c", ")", "\n", "return", "nil", "\n", "}" ]

[ "AddConversation", "implements", "auditlog", ".", "AuditLog", "." ]

[ "func", "(", "l", "*", "bufferedLog", ")", "AddRequest", "(", "r", "auditlog", ".", "Request", ")", "error", "{", "l", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "len", "(", "l", ".", "buffer", ")", ">", "0", "{", "l", ".", "deferMessage", "(", "r", ")", "\n", "var", "err", "error", "\n", "if", "l", ".", "interesting", "(", "r", ")", "{", "err", "=", "l", ".", "flush", "(", ")", "\n", "}", "\n", "l", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "err", "\n", "}", "\n", "l", ".", "mu", ".", "Unlock", "(", ")", "\n", "// We've already flushed messages, forward this on", "// immediately.", "return", "l", ".", "dest", ".", "AddRequest", "(", "r", ")", "\n", "}" ]

[ "AddRequest", "implements", "auditlog", ".", "AuditLog", "." ]

[ "func", "(", "l", "*", "bufferedLog", ")", "AddResponse", "(", "r", "auditlog", ".", "ResponseErrors", ")", "error", "{", "l", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "len", "(", "l", ".", "buffer", ")", ">", "0", "{", "l", ".", "deferMessage", "(", "r", ")", "\n", "l", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "l", ".", "mu", ".", "Unlock", "(", ")", "\n", "// We've already flushed messages, forward this on", "// immediately.", "return", "l", ".", "dest", ".", "AddResponse", "(", "r", ")", "\n", "}" ]

[ "AddResponse", "implements", "auditlog", ".", "AuditLog", "." ]

[ "func", "IsValidLinkLayerDeviceType", "(", "value", "string", ")", "bool", "{", "switch", "LinkLayerDeviceType", "(", "value", ")", "{", "case", "LoopbackDevice", ",", "EthernetDevice", ",", "VLAN_8021QDevice", ",", "BondDevice", ",", "BridgeDevice", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsValidLinkLayerDeviceType", "returns", "whether", "the", "given", "value", "is", "a", "valid", "link", "-", "layer", "network", "device", "type", "." ]

[ "func", "(", "st", "*", "State", ")", "AllLinkLayerDevices", "(", ")", "(", "devices", "[", "]", "*", "LinkLayerDevice", ",", "err", "error", ")", "{", "devicesCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "linkLayerDevicesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "sdocs", ":=", "[", "]", "linkLayerDeviceDoc", "{", "}", "\n", "err", "=", "devicesCollection", ".", "Find", "(", "nil", ")", ".", "All", "(", "&", "sdocs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "d", ":=", "range", "sdocs", "{", "devices", "=", "append", "(", "devices", ",", "newLinkLayerDevice", "(", "st", ",", "d", ")", ")", "\n", "}", "\n", "return", "devices", ",", "nil", "\n", "}" ]

[ "AllLinkLayerDevices", "returns", "all", "link", "layer", "devices", "in", "the", "model", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "DocID", "(", ")", "string", "{", "return", "dev", ".", "st", ".", "docID", "(", "dev", ".", "doc", ".", "DocID", ")", "\n", "}" ]

[ "DocID", "returns", "the", "globally", "unique", "ID", "of", "the", "link", "-", "layer", "device", "including", "the", "model", "UUID", "as", "prefix", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "ProviderID", "(", ")", "network", ".", "Id", "{", "return", "network", ".", "Id", "(", "dev", ".", "doc", ".", "ProviderID", ")", "\n", "}" ]

[ "ProviderID", "returns", "the", "provider", "-", "specific", "device", "ID", "if", "set", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "Machine", "(", ")", "(", "*", "Machine", ",", "error", ")", "{", "return", "dev", ".", "st", ".", "Machine", "(", "dev", ".", "doc", ".", "MachineID", ")", "\n", "}" ]

[ "Machine", "returns", "the", "Machine", "this", "device", "belongs", "to", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "ParentDevice", "(", ")", "(", "*", "LinkLayerDevice", ",", "error", ")", "{", "if", "dev", ".", "doc", ".", "ParentName", "==", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "parentDeviceName", ",", "parentMachineID", ":=", "dev", ".", "parentDeviceNameAndMachineID", "(", ")", "\n", "return", "dev", ".", "machineProxy", "(", "parentMachineID", ")", ".", "LinkLayerDevice", "(", "parentDeviceName", ")", "\n", "}" ]

[ "ParentDevice", "returns", "the", "LinkLayerDevice", "corresponding", "to", "the", "parent", "device", "of", "this", "device", "if", "set", ".", "When", "no", "parent", "device", "name", "is", "set", "it", "returns", "nil", "and", "no", "error", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "Remove", "(", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "dev", ")", "\n\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "if", "attempt", ">", "0", "{", "if", "err", "=", "dev", ".", "errNoOperationsIfMissing", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "ops", ",", "err", ":=", "removeLinkLayerDeviceOps", "(", "dev", ".", "st", ",", "dev", ".", "DocID", "(", ")", ",", "dev", ".", "parentDocID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "dev", ".", "ProviderID", "(", ")", "!=", "\"", "\"", "{", "op", ":=", "dev", ".", "st", ".", "networkEntityGlobalKeyRemoveOp", "(", "\"", "\"", ",", "dev", ".", "ProviderID", "(", ")", ")", "\n", "ops", "=", "append", "(", "ops", ",", "op", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "return", "dev", ".", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "Remove", "removes", "the", "device", "if", "it", "exists", ".", "No", "error", "is", "returned", "when", "the", "device", "was", "already", "removed", ".", "ErrParentDeviceHasChildren", "is", "returned", "if", "this", "device", "is", "a", "parent", "to", "one", "or", "more", "existing", "devices", "and", "therefore", "cannot", "be", "removed", "." ]

[ "func", "removeLinkLayerDeviceOps", "(", "st", "*", "State", ",", "linkLayerDeviceDocID", ",", "parentDeviceDocID", "string", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "var", "numChildren", "int", "\n", "if", "parentDeviceDocID", "==", "\"", "\"", "{", "// If not a child, verify it has no children.", "var", "err", "error", "\n", "numChildren", ",", "err", "=", "getParentDeviceNumChildrenRefs", "(", "st", ",", "linkLayerDeviceDocID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "// We know the DocID has a valid format for a global key, hence the last", "// return below is ignored.", "machineID", ",", "deviceName", ",", "canBeGlobalKey", ":=", "parseLinkLayerDeviceGlobalKey", "(", "linkLayerDeviceDocID", ")", "\n", "if", "!", "canBeGlobalKey", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "machineID", ",", "deviceName", ",", ")", "\n", "}", "\n", "if", "numChildren", ">", "0", "{", "return", "nil", ",", "newParentDeviceHasChildrenError", "(", "deviceName", ",", "numChildren", ")", "\n", "}", "\n\n", "var", "ops", "[", "]", "txn", ".", "Op", "\n", "if", "parentDeviceDocID", "!=", "\"", "\"", "{", "ops", "=", "append", "(", "ops", ",", "decrementDeviceNumChildrenOp", "(", "parentDeviceDocID", ")", ")", "\n", "}", "\n\n", "addressesQuery", ":=", "findAddressesQuery", "(", "machineID", ",", "deviceName", ")", "\n", "if", "addressesOps", ",", "err", ":=", "st", ".", "removeMatchingIPAddressesDocOps", "(", "addressesQuery", ")", ";", "err", "==", "nil", "{", "ops", "=", "append", "(", "ops", ",", "addressesOps", "...", ")", "\n", "}", "else", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "append", "(", "ops", ",", "removeLinkLayerDeviceDocOp", "(", "linkLayerDeviceDocID", ")", ",", "removeLinkLayerDevicesRefsOp", "(", "linkLayerDeviceDocID", ")", ",", ")", ",", "nil", "\n", "}" ]

[ "removeLinkLayerDeviceOps", "returns", "the", "list", "of", "operations", "needed", "to", "remove", "the", "device", "with", "the", "given", "linkLayerDeviceDocID", "asserting", "it", "still", "exists", "and", "has", "no", "children", "referring", "to", "it", ".", "If", "the", "device", "is", "a", "child", "parentDeviceDocID", "will", "be", "non", "-", "empty", "and", "the", "operations", "includes", "decrementing", "the", "parent", "s", "NumChildren", "." ]

[ "func", "removeLinkLayerDeviceDocOp", "(", "linkLayerDeviceDocID", "string", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesC", ",", "Id", ":", "linkLayerDeviceDocID", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Remove", ":", "true", ",", "}", "\n", "}" ]

[ "removeLinkLayerDeviceDocOp", "returns", "an", "operation", "to", "remove", "the", "linkLayerDeviceDoc", "matching", "the", "given", "linkLayerDeviceDocID", "asserting", "it", "still", "exists", "." ]

[ "func", "removeLinkLayerDeviceUnconditionallyOps", "(", "linkLayerDeviceDocID", "string", ")", "[", "]", "txn", ".", "Op", "{", "// Reuse the regular remove ops, but drop their asserts.", "removeDeviceDocOp", ":=", "removeLinkLayerDeviceDocOp", "(", "linkLayerDeviceDocID", ")", "\n", "removeDeviceDocOp", ".", "Assert", "=", "nil", "\n", "removeRefsOp", ":=", "removeLinkLayerDevicesRefsOp", "(", "linkLayerDeviceDocID", ")", "\n", "removeRefsOp", ".", "Assert", "=", "nil", "\n\n", "return", "[", "]", "txn", ".", "Op", "{", "removeDeviceDocOp", ",", "removeRefsOp", ",", "}", "\n", "}" ]

[ "removeLinkLayerDeviceUnconditionallyOps", "returns", "the", "list", "of", "operations", "to", "unconditionally", "remove", "the", "device", "matching", "the", "given", "linkLayerDeviceDocID", "along", "with", "its", "linkLayerDevicesRefsDoc", ".", "No", "asserts", "are", "included", "for", "the", "existence", "of", "both", "documents", "." ]

[ "func", "insertLinkLayerDeviceDocOp", "(", "newDoc", "*", "linkLayerDeviceDoc", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesC", ",", "Id", ":", "newDoc", ".", "DocID", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "*", "newDoc", ",", "}", "\n", "}" ]

[ "insertLinkLayerDeviceDocOp", "returns", "an", "operation", "inserting", "the", "given", "newDoc", "asserting", "it", "does", "not", "exist", "yet", "." ]

[ "func", "updateLinkLayerDeviceDocOp", "(", "existingDoc", ",", "newDoc", "*", "linkLayerDeviceDoc", ")", "(", "txn", ".", "Op", ",", "bool", ")", "{", "changes", ":=", "make", "(", "bson", ".", "M", ")", "\n", "if", "existingDoc", ".", "ProviderID", "==", "\"", "\"", "&&", "newDoc", ".", "ProviderID", "!=", "\"", "\"", "{", "// Only allow changing the ProviderID if it was empty.", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "ProviderID", "\n", "}", "\n", "if", "existingDoc", ".", "Type", "!=", "newDoc", ".", "Type", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "Type", "\n", "}", "\n", "if", "existingDoc", ".", "MTU", "!=", "newDoc", ".", "MTU", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "MTU", "\n", "}", "\n", "if", "existingDoc", ".", "MACAddress", "!=", "newDoc", ".", "MACAddress", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "MACAddress", "\n", "}", "\n", "if", "existingDoc", ".", "IsAutoStart", "!=", "newDoc", ".", "IsAutoStart", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "IsAutoStart", "\n", "}", "\n", "if", "existingDoc", ".", "IsUp", "!=", "newDoc", ".", "IsUp", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "IsUp", "\n", "}", "\n", "if", "existingDoc", ".", "ParentName", "!=", "newDoc", ".", "ParentName", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "ParentName", "\n", "}", "\n\n", "var", "updates", "bson", ".", "D", "\n", "if", "len", "(", "changes", ")", ">", "0", "{", "updates", "=", "append", "(", "updates", ",", "bson", ".", "DocElem", "{", "Name", ":", "\"", "\"", ",", "Value", ":", "changes", "}", ")", "\n", "}", "\n\n", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesC", ",", "Id", ":", "existingDoc", ".", "DocID", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Update", ":", "updates", ",", "}", ",", "len", "(", "updates", ")", ">", "0", "\n", "}" ]

[ "updateLinkLayerDeviceDocOp", "returns", "an", "operation", "updating", "the", "fields", "of", "existingDoc", "with", "the", "respective", "values", "of", "those", "fields", "in", "newDoc", ".", "DocID", "ModelUUID", "MachineID", "and", "Name", "cannot", "be", "changed", ".", "ProviderID", "cannot", "be", "changed", "once", "set", ".", "In", "all", "other", "cases", "newDoc", "values", "overwrites", "existingDoc", "values", "." ]

[ "func", "assertLinkLayerDeviceExistsOp", "(", "linkLayerDeviceDocID", "string", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesC", ",", "Id", ":", "linkLayerDeviceDocID", ",", "Assert", ":", "txn", ".", "DocExists", ",", "}", "\n", "}" ]

[ "assertLinkLayerDeviceExistsOp", "returns", "an", "operation", "asserting", "the", "document", "matching", "linkLayerDeviceDocID", "exists", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dev", ".", "doc", ".", "Type", ",", "dev", ".", "doc", ".", "Name", ",", "dev", ".", "doc", ".", "MachineID", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "the", "device", "." ]

[ "func", "IsValidLinkLayerDeviceName", "(", "name", "string", ")", "bool", "{", "if", "runtimeGOOS", "==", "\"", "\"", "{", "return", "isValidLinuxDeviceName", "(", "name", ")", "\n", "}", "\n", "hasHash", ":=", "strings", ".", "Contains", "(", "name", ",", "\"", "\"", ")", "\n", "return", "!", "hasHash", "&&", "stringLengthBetween", "(", "name", ",", "1", ",", "255", ")", "\n", "}" ]

[ "IsValidLinkLayerDeviceName", "returns", "whether", "the", "given", "name", "is", "a", "valid", "network", "link", "-", "layer", "device", "name", "depending", "on", "the", "runtime", ".", "GOOS", "value", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "Addresses", "(", ")", "(", "[", "]", "*", "Address", ",", "error", ")", "{", "var", "allAddresses", "[", "]", "*", "Address", "\n", "callbackFunc", ":=", "func", "(", "resultDoc", "*", "ipAddressDoc", ")", "{", "allAddresses", "=", "append", "(", "allAddresses", ",", "newIPAddress", "(", "dev", ".", "st", ",", "*", "resultDoc", ")", ")", "\n", "}", "\n\n", "findQuery", ":=", "findAddressesQuery", "(", "dev", ".", "doc", ".", "MachineID", ",", "dev", ".", "doc", ".", "Name", ")", "\n", "if", "err", ":=", "dev", ".", "st", ".", "forEachIPAddressDoc", "(", "findQuery", ",", "callbackFunc", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "allAddresses", ",", "nil", "\n", "}" ]

[ "Addresses", "returns", "all", "IP", "addresses", "assigned", "to", "the", "device", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "RemoveAddresses", "(", ")", "error", "{", "findQuery", ":=", "findAddressesQuery", "(", "dev", ".", "doc", ".", "MachineID", ",", "dev", ".", "doc", ".", "Name", ")", "\n", "ops", ",", "err", ":=", "dev", ".", "st", ".", "removeMatchingIPAddressesDocOps", "(", "findQuery", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "dev", ".", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", "\n", "}" ]

[ "RemoveAddresses", "removes", "all", "IP", "addresses", "assigned", "to", "the", "device", "." ]

[ "func", "(", "dev", "*", "LinkLayerDevice", ")", "EthernetDeviceForBridge", "(", "name", "string", ")", "(", "LinkLayerDeviceArgs", ",", "error", ")", "{", "if", "dev", ".", "Type", "(", ")", "!=", "BridgeDevice", "{", "return", "LinkLayerDeviceArgs", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "dev", ".", "Type", "(", ")", ")", "\n", "}", "\n", "return", "LinkLayerDeviceArgs", "{", "Name", ":", "name", ",", "Type", ":", "EthernetDevice", ",", "MACAddress", ":", "network", ".", "GenerateVirtualMACAddress", "(", ")", ",", "MTU", ":", "dev", ".", "MTU", "(", ")", ",", "IsUp", ":", "true", ",", "IsAutoStart", ":", "true", ",", "ParentName", ":", "dev", ".", "globalKey", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "EthernetDeviceForBridge", "returns", "LinkLayerDeviceArgs", "representing", "an", "ethernet", "device", "with", "the", "input", "name", "and", "this", "device", "as", "its", "parent", ".", "If", "the", "device", "is", "not", "a", "bridge", "an", "error", "is", "returned", "." ]

[ "func", "(", "c", "*", "removeCommand", ")", "SetFlags", "(", "f", "*", "gnuflag", ".", "FlagSet", ")", "{", "c", ".", "ControllerCommandBase", ".", "SetFlags", "(", "f", ")", "\n", "f", ".", "BoolVar", "(", "&", "c", ".", "ConfirmDelete", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "f", ".", "BoolVar", "(", "&", "c", ".", "ConfirmDelete", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "}" ]

[ "SetFlags", "adds", "command", "specific", "flags", "and", "then", "returns", "the", "flagset", "." ]

[ "func", "NewAPI", "(", "caller", "base", ".", "APICaller", ",", "tag", "names", ".", "Tag", ")", "(", "*", "API", ",", "error", ")", "{", "if", "caller", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "tag", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "API", "{", "facade", ":", "base", ".", "NewFacadeCaller", "(", "caller", ",", "proxyUpdaterFacade", ")", ",", "tag", ":", "tag", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAPI", "returns", "a", "new", "api", "client", "facade", "instance", "." ]

[ "func", "(", "api", "*", "API", ")", "WatchForProxyConfigAndAPIHostPortChanges", "(", ")", "(", "watcher", ".", "NotifyWatcher", ",", "error", ")", "{", "var", "results", "params", ".", "NotifyWatchResults", "\n", "args", ":=", "params", ".", "Entities", "{", "Entities", ":", "[", "]", "params", ".", "Entity", "{", "{", "Tag", ":", "api", ".", "tag", ".", "String", "(", ")", "}", "}", ",", "}", "\n", "err", ":=", "api", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n\n", "return", "newNotifyWatcher", "(", "api", ".", "facade", ".", "RawAPICaller", "(", ")", ",", "result", ")", ",", "nil", "\n", "}" ]

[ "WatchForProxyConfigAndAPIHostPortChanges", "returns", "a", "NotifyWatcher", "waiting", "for", "changes", "in", "the", "proxy", "configuration", "or", "API", "host", "ports" ]

[ "func", "NewStateCAASOperatorUpgraderAPI", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "API", ",", "error", ")", "{", "authorizer", ":=", "ctx", ".", "Auth", "(", ")", "\n", "broker", ",", "err", ":=", "stateenvirons", ".", "GetNewCAASBrokerFunc", "(", "caas", ".", "New", ")", "(", "ctx", ".", "State", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "NewCAASOperatorUpgraderAPI", "(", "authorizer", ",", "broker", ")", "\n", "}" ]

[ "NewStateCAASOperatorUpgraderAPI", "provides", "the", "signature", "required", "for", "facade", "registration", "." ]

[ "func", "NewCAASOperatorUpgraderAPI", "(", "authorizer", "facade", ".", "Authorizer", ",", "broker", "caas", ".", "Upgrader", ",", ")", "(", "*", "API", ",", "error", ")", "{", "if", "!", "authorizer", ".", "AuthController", "(", ")", "&&", "!", "authorizer", ".", "AuthApplicationAgent", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "&", "API", "{", "auth", ":", "authorizer", ",", "broker", ":", "broker", ",", "}", ",", "nil", "\n", "}" ]

[ "NewCAASOperatorUpgraderAPI", "returns", "a", "new", "CAAS", "operator", "upgrader", "API", "facade", "." ]

[ "func", "(", "api", "*", "API", ")", "UpgradeOperator", "(", "arg", "params", ".", "KubernetesUpgradeArg", ")", "(", "params", ".", "ErrorResult", ",", "error", ")", "{", "serverErr", ":=", "func", "(", "err", "error", ")", "params", ".", "ErrorResult", "{", "return", "params", ".", "ErrorResult", "{", "common", ".", "ServerError", "(", "err", ")", "}", "\n", "}", "\n", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "arg", ".", "AgentTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "serverErr", "(", "err", ")", ",", "nil", "\n", "}", "\n", "if", "!", "api", ".", "auth", ".", "AuthOwner", "(", "tag", ")", "{", "return", "serverErr", "(", "common", ".", "ErrPerm", ")", ",", "nil", "\n", "}", "\n", "appName", ":=", "tag", ".", "Id", "(", ")", "\n\n", "// Machines representing controllers really mean the controller operator.", "if", "tag", ".", "Kind", "(", ")", "==", "names", ".", "MachineTagKind", "{", "appName", "=", "bootstrap", ".", "ControllerModelName", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "appName", ")", "\n", "err", "=", "api", ".", "broker", ".", "Upgrade", "(", "appName", ",", "arg", ".", "Version", ")", "\n", "if", "err", "!=", "nil", "{", "return", "serverErr", "(", "err", ")", ",", "nil", "\n", "}", "\n", "return", "params", ".", "ErrorResult", "{", "}", ",", "nil", "\n", "}" ]

[ "UpgradeOperator", "upgrades", "the", "operator", "for", "the", "specified", "agents", "." ]

[ "func", "(", "c", "*", "exposeCommand", ")", "Run", "(", "_", "*", "cmd", ".", "Context", ")", "error", "{", "client", ",", "err", ":=", "c", ".", "getAPI", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "return", "block", ".", "ProcessBlockedError", "(", "client", ".", "Expose", "(", "c", ".", "ApplicationName", ")", ",", "block", ".", "BlockChange", ")", "\n", "}" ]

[ "Run", "changes", "the", "juju", "-", "managed", "firewall", "to", "expose", "any", "ports", "that", "were", "also", "explicitly", "marked", "by", "units", "as", "open", "." ]

[ "func", "NewValueWorker", "(", "value", "interface", "{", "}", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "if", "value", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "w", ":=", "&", "valueWorker", "{", "value", ":", "value", ",", "}", "\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "<-", "w", ".", "tomb", ".", "Dying", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "NewValueWorker", "returns", "a", "degenerate", "worker", "that", "exposes", "the", "supplied", "value", "when", "passed", "into", "ValueWorkerOutput", ".", "Please", "do", "not", "supply", "values", "that", "have", "their", "own", "dependency", "or", "lifecycle", "considerations", ";", "such", "values", "will", "subvert", "the", "operation", "of", "any", "containing", "dependency", ".", "Engine", "by", "insulating", "it", "from", "the", "failures", "and", "dependency", "changes", "of", "the", "contained", "value", "." ]

[ "func", "ValueWorkerOutput", "(", "in", "worker", ".", "Worker", ",", "out", "interface", "{", "}", ")", "error", "{", "inWorker", ",", "_", ":=", "in", ".", "(", "*", "valueWorker", ")", "\n", "if", "inWorker", "==", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "in", ")", "\n", "}", "\n", "outV", ":=", "reflect", ".", "ValueOf", "(", "out", ")", "\n", "if", "outV", ".", "Kind", "(", ")", "!=", "reflect", ".", "Ptr", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "out", ")", "\n", "}", "\n", "outValV", ":=", "outV", ".", "Elem", "(", ")", "\n", "outValT", ":=", "outValV", ".", "Type", "(", ")", "\n", "inValV", ":=", "reflect", ".", "ValueOf", "(", "inWorker", ".", "value", ")", "\n", "inValT", ":=", "inValV", ".", "Type", "(", ")", "\n", "if", "!", "inValT", ".", "ConvertibleTo", "(", "outValT", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "out", ")", "\n", "}", "\n", "outValV", ".", "Set", "(", "inValV", ".", "Convert", "(", "outValT", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "ValueWorkerOutput", "sets", "the", "value", "wrapped", "by", "the", "supplied", "valueWorker", "into", "the", "out", "pointer", "if", "type", "-", "compatible", "or", "fails", "." ]

[ "func", "(", "cfg", "*", "windowsCloudConfig", ")", "RenderScript", "(", ")", "(", "string", ",", "error", ")", "{", "// NOTE: This shouldn't really be called on windows as it's used only for", "// initialization via ssh.", "script", ",", "err", ":=", "cfg", ".", "renderWindows", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "string", "(", "script", ")", ",", "err", "\n", "}" ]

[ "RenderScript", "is", "defined", "on", "the", "RenderConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "windowsCloudConfig", ")", "renderWindows", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "winCmds", ":=", "cfg", ".", "RunCmds", "(", ")", "\n", "var", "script", "[", "]", "byte", "\n", "newline", ":=", "\"", "\\r", "\\n", "\"", "\n", "header", ":=", "\"", "\\r", "\\n", "\"", "\n", "script", "=", "append", "(", "script", ",", "header", "...", ")", "\n", "for", "_", ",", "cmd", ":=", "range", "winCmds", "{", "script", "=", "append", "(", "script", ",", "newline", "...", ")", "\n", "script", "=", "append", "(", "script", ",", "cmd", "...", ")", "\n", "}", "\n", "return", "script", ",", "nil", "\n", "}" ]

[ "renderWindows", "is", "a", "helper", "function", "which", "renders", "the", "runCmds", "of", "the", "Windows", "CloudConfig", "to", "a", "PowerShell", "script", "." ]

[ "func", "NewRetryStrategyAPI", "(", "st", "*", "state", ".", "State", ",", "resources", "facade", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ",", ")", "(", "*", "RetryStrategyAPI", ",", "error", ")", "{", "if", "!", "authorizer", ".", "AuthUnitAgent", "(", ")", "&&", "!", "authorizer", ".", "AuthApplicationAgent", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n\n", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "RetryStrategyAPI", "{", "st", ":", "st", ",", "model", ":", "model", ",", "canAccess", ":", "func", "(", ")", "(", "common", ".", "AuthFunc", ",", "error", ")", "{", "return", "authorizer", ".", "AuthOwner", ",", "nil", "\n", "}", ",", "resources", ":", "resources", ",", "}", ",", "nil", "\n", "}" ]

[ "NewRetryStrategyAPI", "creates", "a", "new", "API", "endpoint", "for", "getting", "retry", "strategies", "." ]

[ "func", "(", "h", "*", "RetryStrategyAPI", ")", "RetryStrategy", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "RetryStrategyResults", ",", "error", ")", "{", "results", ":=", "params", ".", "RetryStrategyResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "RetryStrategyResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "canAccess", ",", "err", ":=", "h", ".", "canAccess", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "RetryStrategyResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "config", ",", "err", ":=", "h", ".", "model", ".", "ModelConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "RetryStrategyResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "err", "=", "common", ".", "ErrPerm", "\n", "if", "canAccess", "(", "tag", ")", "{", "// Right now the only real configurable value is ShouldRetry,", "// which is taken from the model.", "// The rest are hardcoded.", "results", ".", "Results", "[", "i", "]", ".", "Result", "=", "&", "params", ".", "RetryStrategy", "{", "ShouldRetry", ":", "config", ".", "AutomaticallyRetryHooks", "(", ")", ",", "MinRetryTime", ":", "MinRetryTime", ",", "MaxRetryTime", ":", "MaxRetryTime", ",", "JitterRetryTime", ":", "JitterRetryTime", ",", "RetryTimeFactor", ":", "RetryTimeFactor", ",", "}", "\n", "err", "=", "nil", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "RetryStrategy", "returns", "RetryStrategyResults", "that", "can", "be", "used", "by", "any", "code", "that", "uses", "to", "configure", "the", "retry", "timer", "that", "s", "currently", "in", "juju", "utils", "." ]

[ "func", "(", "h", "*", "RetryStrategyAPI", ")", "WatchRetryStrategy", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "NotifyWatchResults", ",", "error", ")", "{", "results", ":=", "params", ".", "NotifyWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "NotifyWatchResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "canAccess", ",", "err", ":=", "h", ".", "canAccess", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "NotifyWatchResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "i", ",", "entity", ":=", "range", "args", ".", "Entities", "{", "tag", ",", "err", ":=", "names", ".", "ParseTag", "(", "entity", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "err", "=", "common", ".", "ErrPerm", "\n", "if", "canAccess", "(", "tag", ")", "{", "watch", ":=", "h", ".", "model", ".", "WatchForModelConfigChanges", "(", ")", "\n", "// Consume the initial event. Technically, API calls to Watch", "// 'transmit' the initial event in the Watch response. But", "// NotifyWatchers have no state to transmit.", "if", "_", ",", "ok", ":=", "<-", "watch", ".", "Changes", "(", ")", ";", "ok", "{", "results", ".", "Results", "[", "i", "]", ".", "NotifyWatcherId", "=", "h", ".", "resources", ".", "Register", "(", "watch", ")", "\n", "err", "=", "nil", "\n", "}", "else", "{", "err", "=", "watcher", ".", "EnsureErr", "(", "watch", ")", "\n", "}", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "WatchRetryStrategy", "watches", "for", "changes", "to", "the", "model", ".", "Currently", "we", "only", "allow", "changes", "to", "the", "boolean", "that", "determines", "whether", "retries", "should", "be", "attempted", "or", "not", "." ]

[ "func", "GUIDataSourceBaseURL", "(", ")", "string", "{", "url", ":=", "os", ".", "Getenv", "(", "guiBaseURLEnvVar", ")", "\n", "if", "url", "!=", "\"", "\"", "{", "return", "url", "\n", "}", "\n", "return", "gui", ".", "DefaultBaseURL", "\n", "}" ]

[ "GUIDataSourceBaseURL", "returns", "the", "default", "base", "URL", "to", "use", "for", "the", "Juju", "GUI", "simplestreams", "data", "source", ".", "The", "default", "value", "can", "be", "overridden", "by", "setting", "the", "JUJU_GUI_SIMPLESTREAMS_URL", "environment", "variable", "." ]

[ "func", "NewMultiNotifyWatcher", "(", "w", "...", "NotifyWatcher", ")", "*", "MultiNotifyWatcher", "{", "m", ":=", "&", "MultiNotifyWatcher", "{", "watchers", ":", "w", ",", "changes", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "wg", ".", "Add", "(", "len", "(", "w", ")", ")", "\n", "staging", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "for", "_", ",", "w", ":=", "range", "w", "{", "// Consume the first event of each watcher.", "<-", "w", ".", "Changes", "(", ")", "\n", "go", "func", "(", "wCopy", "NotifyWatcher", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "wCopy", ".", "Wait", "(", ")", "\n", "}", "(", "w", ")", "\n", "// Copy events from the watcher to the staging channel.", "go", "copyEvents", "(", "staging", ",", "w", ".", "Changes", "(", ")", ",", "&", "m", ".", "tomb", ")", "\n", "}", "\n", "m", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "m", ".", "loop", "(", "staging", ")", "\n", "wg", ".", "Wait", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "m", "\n", "}" ]

[ "NewMultiNotifyWatcher", "creates", "a", "NotifyWatcher", "that", "combines", "each", "of", "the", "NotifyWatchers", "passed", "in", ".", "Each", "watcher", "s", "initial", "event", "is", "consumed", "and", "a", "single", "initial", "event", "is", "sent", ".", "Subsequent", "events", "are", "not", "coalesced", "." ]

[ "func", "(", "w", "*", "MultiNotifyWatcher", ")", "loop", "(", "in", "<-", "chan", "struct", "{", "}", ")", "{", "defer", "close", "(", "w", ".", "changes", ")", "\n", "// out is initialised to m.changes to send the initial event.", "out", ":=", "w", ".", "changes", "\n", "var", "timer", "<-", "chan", "time", ".", "Time", "\n", "for", "{", "select", "{", "case", "<-", "w", ".", "tomb", ".", "Dying", "(", ")", ":", "return", "\n", "case", "<-", "in", ":", "if", "timer", "==", "nil", "{", "// TODO(fwereade): 2016-03-17 lp:1558657", "timer", "=", "time", ".", "After", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "case", "<-", "timer", ":", "timer", "=", "nil", "\n", "out", "=", "w", ".", "changes", "\n", "case", "out", "<-", "struct", "{", "}", "{", "}", ":", "out", "=", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "loop", "copies", "events", "from", "the", "input", "channel", "to", "the", "output", "channel", "coalescing", "events", "by", "waiting", "a", "short", "time", "between", "receiving", "and", "sending", "." ]

[ "func", "copyEvents", "(", "out", "chan", "<-", "struct", "{", "}", ",", "in", "<-", "chan", "struct", "{", "}", ",", "tomb", "*", "tomb", ".", "Tomb", ")", "{", "var", "outC", "chan", "<-", "struct", "{", "}", "\n", "for", "{", "select", "{", "case", "<-", "tomb", ".", "Dying", "(", ")", ":", "return", "\n", "case", "_", ",", "ok", ":=", "<-", "in", ":", "if", "!", "ok", "{", "return", "\n", "}", "\n", "outC", "=", "out", "\n", "case", "outC", "<-", "struct", "{", "}", "{", "}", ":", "outC", "=", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "copyEvents", "copies", "channel", "events", "from", "in", "to", "out", "coalescing", "." ]

[ "func", "(", "f", "*", "firewallerFactory", ")", "GetFirewaller", "(", "env", "environs", ".", "Environ", ")", "Firewaller", "{", "return", "&", "switchingFirewaller", "{", "env", ":", "env", ".", "(", "*", "Environ", ")", "}", "\n", "}" ]

[ "GetFirewaller", "implements", "FirewallerFactory" ]

[ "func", "(", "c", "*", "firewallerBase", ")", "GetSecurityGroups", "(", "ctx", "context", ".", "ProviderCallContext", ",", "ids", "...", "instance", ".", "Id", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "securityGroupNames", "[", "]", "string", "\n", "if", "c", ".", "environ", ".", "Config", "(", ")", ".", "FirewallMode", "(", ")", "==", "config", ".", "FwInstance", "{", "instances", ",", "err", ":=", "c", ".", "environ", ".", "Instances", "(", "ctx", ",", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "novaClient", ":=", "c", ".", "environ", ".", "nova", "(", ")", "\n", "securityGroupNames", "=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "ids", ")", ")", "\n", "for", "_", ",", "inst", ":=", "range", "instances", "{", "if", "inst", "==", "nil", "{", "continue", "\n", "}", "\n", "serverId", ",", "err", ":=", "instServerId", "(", "inst", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "groups", ",", "err", ":=", "novaClient", ".", "GetServerSecurityGroups", "(", "string", "(", "inst", ".", "Id", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "group", ":=", "range", "groups", "{", "// We only include the group specifically tied to the instance, not", "// any group global to the model itself.", "suffix", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "environ", ".", "Config", "(", ")", ".", "UUID", "(", ")", ",", "serverId", ")", "\n", "if", "strings", ".", "HasSuffix", "(", "group", ".", "Name", ",", "suffix", ")", "{", "securityGroupNames", "=", "append", "(", "securityGroupNames", ",", "group", ".", "Name", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "securityGroupNames", ",", "nil", "\n", "}" ]

[ "GetSecurityGroups", "implements", "Firewaller", "interface", "." ]

[ "func", "deleteSecurityGroup", "(", "ctx", "context", ".", "ProviderCallContext", ",", "deleteSecurityGroupById", "func", "(", "string", ")", "error", ",", "name", ",", "id", "string", ",", "clock", "clock", ".", "Clock", ",", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "name", ")", "\n", "err", ":=", "retry", ".", "Call", "(", "retry", ".", "CallArgs", "{", "Func", ":", "func", "(", ")", "error", "{", "if", "err", ":=", "deleteSecurityGroupById", "(", "id", ")", ";", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ",", "NotifyFunc", ":", "func", "(", "err", "error", ",", "attempt", "int", ")", "{", "if", "attempt", "%", "4", "==", "0", "{", "message", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", "\n", "if", "attempt", "!=", "4", "{", "message", "=", "\"", "\"", "+", "message", "\n", "}", "\n", "logger", ".", "Debugf", "(", "message", ")", "\n", "}", "\n", "}", ",", "Attempts", ":", "30", ",", "Delay", ":", "time", ".", "Second", ",", "Clock", ":", "clock", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "}" ]

[ "deleteSecurityGroup", "attempts", "to", "delete", "the", "security", "group", ".", "Should", "it", "fail", "the", "deletion", "is", "retried", "due", "to", "timing", "issues", "in", "openstack", ".", "A", "security", "group", "cannot", "be", "deleted", "while", "it", "is", "in", "use", ".", "Theoretically", "we", "terminate", "all", "the", "instances", "before", "we", "attempt", "to", "delete", "the", "associated", "security", "groups", "but", "in", "practice", "neutron", "hasn", "t", "always", "finished", "with", "the", "instance", "before", "it", "returns", "so", "there", "is", "a", "race", "condition", "where", "we", "think", "the", "instance", "is", "terminated", "and", "hence", "attempt", "to", "delete", "the", "security", "groups", "but", "nova", "still", "has", "it", "around", "internally", ".", "To", "attempt", "to", "catch", "this", "timing", "issue", "deletion", "of", "the", "groups", "is", "tried", "multiple", "times", "." ]

[ "func", "(", "c", "*", "neutronFirewaller", ")", "ensureGroup", "(", "name", "string", ",", "rules", "[", "]", "neutron", ".", "RuleInfoV2", ")", "(", "neutron", ".", "SecurityGroupV2", ",", "error", ")", "{", "neutronClient", ":=", "c", ".", "environ", ".", "neutron", "(", ")", "\n", "var", "group", "neutron", ".", "SecurityGroupV2", "\n\n", "// Due to parallelization of the provisioner, it's possible that we try", "// to create the model security group a second time before the first time", "// is complete causing failures.", "c", ".", "ensureGroupMutex", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "ensureGroupMutex", ".", "Unlock", "(", ")", "\n", "// First attempt to look up an existing group by name.", "groupsFound", ",", "err", ":=", "neutronClient", ".", "SecurityGroupByNameV2", "(", "name", ")", "\n", "// a list is returned, but there should be only one", "if", "err", "==", "nil", "&&", "len", "(", "groupsFound", ")", "==", "1", "{", "group", "=", "groupsFound", "[", "0", "]", "\n", "}", "else", "if", "err", "!=", "nil", "&&", "strings", ".", "Contains", "(", "err", ".", "Error", "(", ")", ",", "\"", "\"", ")", "{", "// TODO(hml): We should use a typed error here. SecurityGroupByNameV2", "// doesn't currently return one for this case.", "g", ",", "err", ":=", "neutronClient", ".", "CreateSecurityGroupV2", "(", "name", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "zeroGroup", ",", "err", "\n", "}", "\n", "group", "=", "*", "g", "\n", "}", "else", "if", "err", "==", "nil", "&&", "len", "(", "groupsFound", ")", ">", "1", "{", "// TODO(hml): Add unit test for this case", "return", "zeroGroup", ",", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "}", "else", "{", "return", "zeroGroup", ",", "err", "\n", "}", "\n\n", "have", ":=", "newRuleInfoSetFromRules", "(", "group", ".", "Rules", ")", "\n", "want", ":=", "newRuleInfoSetFromRuleInfo", "(", "rules", ")", "\n\n", "// Find rules we want to delete, that we have but don't want, and", "// delete them.", "remove", ":=", "make", "(", "ruleInfoSet", ")", "\n", "for", "k", ":=", "range", "have", "{", "// Neutron creates 2 egress rules with any new Security Group.", "// Keep them.", "if", "_", ",", "ok", ":=", "want", "[", "k", "]", ";", "!", "ok", "&&", "k", ".", "Direction", "!=", "\"", "\"", "{", "remove", "[", "k", "]", "=", "have", "[", "k", "]", "\n", "}", "\n", "}", "\n", "for", "_", ",", "ruleId", ":=", "range", "remove", "{", "if", "err", "=", "neutronClient", ".", "DeleteSecurityGroupRuleV2", "(", "ruleId", ")", ";", "err", "!=", "nil", "{", "return", "zeroGroup", ",", "err", "\n", "}", "\n", "}", "\n\n", "// Find rules we want to add, that we want but don't have, and add", "// them.", "add", ":=", "make", "(", "ruleInfoSet", ")", "\n", "for", "k", ":=", "range", "want", "{", "if", "_", ",", "ok", ":=", "have", "[", "k", "]", ";", "!", "ok", "{", "add", "[", "k", "]", "=", "want", "[", "k", "]", "\n", "}", "\n", "}", "\n", "for", "rule", ":=", "range", "add", "{", "rule", ".", "ParentGroupId", "=", "group", ".", "Id", "\n", "// Neutron translates empty RemoteIPPrefix into", "// 0.0.0.0/0 or ::/0 instead of ParentGroupId", "// when EthernetType is set", "if", "rule", ".", "RemoteIPPrefix", "==", "\"", "\"", "{", "rule", ".", "RemoteGroupId", "=", "group", ".", "Id", "\n", "}", "\n", "if", "_", ",", "err", ":=", "neutronClient", ".", "CreateSecurityGroupRuleV2", "(", "rule", ")", ";", "err", "!=", "nil", "{", "return", "zeroGroup", ",", "err", "\n", "}", "\n", "}", "\n\n", "// Since we may have done a few add or delete rules, get a new", "// copy of the security group to return containing the end", "// list of rules.", "groupsFound", ",", "err", "=", "neutronClient", ".", "SecurityGroupByNameV2", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "zeroGroup", ",", "err", "\n", "}", "else", "if", "len", "(", "groupsFound", ")", ">", "1", "{", "// TODO(hml): Add unit test for this case", "return", "zeroGroup", ",", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "}", "\n", "return", "groupsFound", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "ensureGroup", "returns", "the", "security", "group", "with", "name", "and", "rules", ".", "If", "a", "group", "with", "name", "does", "not", "exist", "one", "will", "be", "created", ".", "If", "it", "exists", "its", "permissions", "are", "set", "to", "rules", "." ]

[ "func", "newRuleInfoSetFromRules", "(", "rules", "[", "]", "neutron", ".", "SecurityGroupRuleV2", ")", "ruleInfoSet", "{", "m", ":=", "make", "(", "ruleInfoSet", ")", "\n", "for", "_", ",", "r", ":=", "range", "rules", "{", "k", ":=", "neutron", ".", "RuleInfoV2", "{", "Direction", ":", "r", ".", "Direction", ",", "EthernetType", ":", "r", ".", "EthernetType", ",", "RemoteIPPrefix", ":", "r", ".", "RemoteIPPrefix", ",", "}", "\n", "if", "r", ".", "IPProtocol", "!=", "nil", "{", "k", ".", "IPProtocol", "=", "*", "r", ".", "IPProtocol", "\n", "}", "\n", "if", "r", ".", "PortRangeMax", "!=", "nil", "{", "k", ".", "PortRangeMax", "=", "*", "r", ".", "PortRangeMax", "\n", "}", "\n", "if", "r", ".", "PortRangeMin", "!=", "nil", "{", "k", ".", "PortRangeMin", "=", "*", "r", ".", "PortRangeMin", "\n", "}", "\n", "m", "[", "k", "]", "=", "r", ".", "Id", "\n", "}", "\n", "return", "m", "\n", "}" ]

[ "newRuleSetForGroup", "returns", "a", "set", "of", "all", "of", "the", "permissions", "in", "a", "given", "slice", "of", "SecurityGroupRules", ".", "It", "ignores", "the", "group", "id", "the", "remove", "group", "id", "and", "tenant", "id", ".", "Keep", "the", "rule", "id", "to", "delete", "the", "rule", "if", "necessary", "." ]

[ "func", "newRuleInfoSetFromRuleInfo", "(", "rules", "[", "]", "neutron", ".", "RuleInfoV2", ")", "ruleInfoSet", "{", "m", ":=", "make", "(", "ruleInfoSet", ")", "\n", "for", "_", ",", "r", ":=", "range", "rules", "{", "k", ":=", "neutron", ".", "RuleInfoV2", "{", "Direction", ":", "r", ".", "Direction", ",", "IPProtocol", ":", "r", ".", "IPProtocol", ",", "PortRangeMin", ":", "r", ".", "PortRangeMin", ",", "PortRangeMax", ":", "r", ".", "PortRangeMax", ",", "EthernetType", ":", "r", ".", "EthernetType", ",", "RemoteIPPrefix", ":", "r", ".", "RemoteIPPrefix", ",", "}", "\n", "m", "[", "k", "]", "=", "\"", "\"", "\n", "}", "\n", "return", "m", "\n", "}" ]

[ "newRuleSetForGroup", "returns", "a", "set", "of", "all", "of", "the", "permissions", "in", "a", "given", "slice", "of", "RuleInfo", ".", "It", "ignores", "the", "rule", "id", "the", "group", "id", "the", "remove", "group", "id", "and", "tenant", "id", "." ]

[ "func", "(", "c", "*", "neutronFirewaller", ")", "DeleteAllControllerGroups", "(", "ctx", "context", ".", "ProviderCallContext", ",", "controllerUUID", "string", ")", "error", "{", "return", "deleteSecurityGroupsMatchingName", "(", "ctx", ",", "c", ".", "deleteSecurityGroups", ",", "c", ".", "jujuControllerGroupPrefix", "(", "controllerUUID", ")", ")", "\n", "}" ]

[ "DeleteAllControllerGroups", "implements", "Firewaller", "interface", "." ]

[ "func", "(", "c", "*", "neutronFirewaller", ")", "matchingGroup", "(", "ctx", "context", ".", "ProviderCallContext", ",", "nameRegExp", "string", ")", "(", "neutron", ".", "SecurityGroupV2", ",", "error", ")", "{", "re", ",", "err", ":=", "regexp", ".", "Compile", "(", "nameRegExp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "neutron", ".", "SecurityGroupV2", "{", "}", ",", "err", "\n", "}", "\n", "neutronClient", ":=", "c", ".", "environ", ".", "neutron", "(", ")", "\n", "allGroups", ",", "err", ":=", "neutronClient", ".", "ListSecurityGroupsV2", "(", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "neutron", ".", "SecurityGroupV2", "{", "}", ",", "err", "\n", "}", "\n", "var", "matchingGroups", "[", "]", "neutron", ".", "SecurityGroupV2", "\n", "for", "_", ",", "group", ":=", "range", "allGroups", "{", "if", "re", ".", "MatchString", "(", "group", ".", "Name", ")", "{", "matchingGroups", "=", "append", "(", "matchingGroups", ",", "group", ")", "\n", "}", "\n", "}", "\n", "numMatching", ":=", "len", "(", "matchingGroups", ")", "\n", "if", "numMatching", "==", "0", "{", "return", "neutron", ".", "SecurityGroupV2", "{", "}", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "nameRegExp", ")", "\n", "}", "else", "if", "numMatching", ">", "1", "{", "return", "neutron", ".", "SecurityGroupV2", "{", "}", ",", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "numMatching", ",", "nameRegExp", ")", ")", "\n", "}", "\n", "return", "matchingGroups", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "Matching", "a", "security", "group", "by", "name", "only", "works", "if", "each", "name", "is", "unqiue", ".", "Neutron", "security", "groups", "are", "not", "required", "to", "have", "unique", "names", ".", "Juju", "constructs", "unique", "names", "but", "there", "are", "frequently", "multiple", "matches", "to", "default" ]

[ "func", "secGroupMatchesIngressRule", "(", "secGroupRule", "neutron", ".", "SecurityGroupRuleV2", ",", "rule", "network", ".", "IngressRule", ")", "bool", "{", "if", "secGroupRule", ".", "IPProtocol", "==", "nil", "||", "secGroupRule", ".", "PortRangeMax", "==", "nil", "||", "*", "secGroupRule", ".", "PortRangeMax", "==", "0", "||", "secGroupRule", ".", "PortRangeMin", "==", "nil", "||", "*", "secGroupRule", ".", "PortRangeMin", "==", "0", "{", "return", "false", "\n", "}", "\n", "portsMatch", ":=", "*", "secGroupRule", ".", "IPProtocol", "==", "rule", ".", "Protocol", "&&", "*", "secGroupRule", ".", "PortRangeMin", "==", "rule", ".", "FromPort", "&&", "*", "secGroupRule", ".", "PortRangeMax", "==", "rule", ".", "ToPort", "\n", "if", "!", "portsMatch", "{", "return", "false", "\n", "}", "\n", "// The ports match, so if the security group RemoteIPPrefix matches *any* of the", "// rule's source ranges, then that's a match.", "if", "len", "(", "rule", ".", "SourceCIDRs", ")", "==", "0", "{", "return", "secGroupRule", ".", "RemoteIPPrefix", "==", "\"", "\"", "||", "secGroupRule", ".", "RemoteIPPrefix", "==", "\"", "\"", "\n", "}", "\n", "for", "_", ",", "r", ":=", "range", "rule", ".", "SourceCIDRs", "{", "if", "r", "==", "secGroupRule", ".", "RemoteIPPrefix", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "secGroupMatchesIngressRule", "checks", "if", "supplied", "nova", "security", "group", "rule", "matches", "the", "ingress", "rule" ]

[ "func", "(", "m", "*", "Machine", ")", "ActiveSubnets", "(", ")", "(", "[", "]", "names", ".", "SubnetTag", ",", "error", ")", "{", "var", "results", "params", ".", "StringsResults", "\n", "args", ":=", "params", ".", "Entities", "{", "Entities", ":", "[", "]", "params", ".", "Entity", "{", "{", "Tag", ":", "m", ".", "tag", ".", "String", "(", ")", "}", "}", ",", "}", "\n", "err", ":=", "m", ".", "st", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n", "// Convert string tags to names.SubnetTag before returning.", "tags", ":=", "make", "(", "[", "]", "names", ".", "SubnetTag", ",", "len", "(", "result", ".", "Result", ")", ")", "\n", "for", "i", ",", "tag", ":=", "range", "result", ".", "Result", "{", "var", "subnetTag", "names", ".", "SubnetTag", "\n", "if", "tag", "!=", "\"", "\"", "{", "subnetTag", ",", "err", "=", "names", ".", "ParseSubnetTag", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "tags", "[", "i", "]", "=", "subnetTag", "\n", "}", "\n", "return", "tags", ",", "nil", "\n", "}" ]

[ "ActiveSubnets", "returns", "a", "list", "of", "subnet", "tags", "for", "which", "the", "machine", "has", "opened", "ports", "." ]

[ "func", "(", "m", "*", "Machine", ")", "OpenedPorts", "(", "subnetTag", "names", ".", "SubnetTag", ")", "(", "map", "[", "network", ".", "PortRange", "]", "names", ".", "UnitTag", ",", "error", ")", "{", "var", "results", "params", ".", "MachinePortsResults", "\n", "var", "subnetTagAsString", "string", "\n", "if", "subnetTag", ".", "Id", "(", ")", "!=", "\"", "\"", "{", "subnetTagAsString", "=", "subnetTag", ".", "String", "(", ")", "\n", "}", "\n", "args", ":=", "params", ".", "MachinePortsParams", "{", "Params", ":", "[", "]", "params", ".", "MachinePorts", "{", "{", "MachineTag", ":", "m", ".", "tag", ".", "String", "(", ")", ",", "SubnetTag", ":", "subnetTagAsString", "}", ",", "}", ",", "}", "\n", "err", ":=", "m", ".", "st", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n", "// Convert string tags to names.UnitTag before returning.", "endResult", ":=", "make", "(", "map", "[", "network", ".", "PortRange", "]", "names", ".", "UnitTag", ")", "\n", "for", "_", ",", "ports", ":=", "range", "result", ".", "Ports", "{", "unitTag", ",", "err", ":=", "names", ".", "ParseUnitTag", "(", "ports", ".", "UnitTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "endResult", "[", "ports", ".", "PortRange", ".", "NetworkPortRange", "(", ")", "]", "=", "unitTag", "\n", "}", "\n", "return", "endResult", ",", "nil", "\n", "}" ]

[ "OpenedPorts", "returns", "a", "map", "of", "network", ".", "PortRange", "to", "unit", "tag", "for", "all", "opened", "port", "ranges", "on", "the", "machine", "for", "the", "subnet", "matching", "given", "subnetTag", "." ]

[ "func", "(", "st", "*", "State", ")", "ResumeTransactions", "(", ")", "error", "{", "runner", ",", "closer", ":=", "st", ".", "database", ".", "TransactionRunner", "(", ")", "\n", "defer", "closer", "(", ")", "\n", "return", "runner", ".", "ResumeTransactions", "(", ")", "\n", "}" ]

[ "ResumeTransactions", "resumes", "all", "pending", "transactions", "." ]

[ "func", "(", "st", "*", "State", ")", "MaybePruneTransactions", "(", ")", "error", "{", "runner", ",", "closer", ":=", "st", ".", "database", ".", "TransactionRunner", "(", ")", "\n", "defer", "closer", "(", ")", "\n", "cfg", ",", "err", ":=", "st", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Prune txns when txn count has increased by 10% since last prune.", "return", "runner", ".", "MaybePruneTransactions", "(", "jujutxn", ".", "PruneOptions", "{", "PruneFactor", ":", "1.1", ",", "MinNewTransactions", ":", "1000", ",", "MaxNewTransactions", ":", "100000", ",", "MaxTime", ":", "time", ".", "Now", "(", ")", ".", "Add", "(", "-", "time", ".", "Hour", ")", ",", "MaxBatchTransactions", ":", "cfg", ".", "MaxPruneTxnBatchSize", "(", ")", ",", "MaxBatches", ":", "cfg", ".", "MaxPruneTxnPasses", "(", ")", ",", "SmallBatchTransactionCount", ":", "cfg", ".", "PruneTxnQueryCount", "(", ")", ",", "BatchTransactionSleepTime", ":", "cfg", ".", "PruneTxnSleepTime", "(", ")", ",", "}", ")", "\n", "}" ]

[ "MaybePruneTransactions", "removes", "data", "for", "completed", "transactions", "." ]

[ "func", "(", "r", "*", "multiModelRunner", ")", "RunTransaction", "(", "tx", "*", "jujutxn", ".", "Transaction", ")", "error", "{", "if", "len", "(", "tx", ".", "Ops", ")", "==", "0", "{", "stack", ":=", "shortStack", "(", ")", "\n", "// It is a warning that should be reported to us, but we definitely", "// don't want to clutter up logs so we'll only write it once.", "if", "!", "seenShortStacks", "[", "stack", "]", "{", "seenShortStacks", "[", "stack", "]", "=", "true", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "stack", ")", "\n", "}", "\n", "}", "\n", "newOps", ",", "err", ":=", "r", ".", "updateOps", "(", "tx", ".", "Ops", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "tx", ".", "Ops", "=", "newOps", "\n", "return", "r", ".", "rawRunner", ".", "RunTransaction", "(", "tx", ")", "\n", "}" ]

[ "RunTransaction", "is", "part", "of", "the", "jujutxn", ".", "Runner", "interface", ".", "Operations", "that", "affect", "multi", "-", "model", "collections", "will", "be", "modified", "to", "ensure", "correct", "interaction", "with", "these", "collections", "." ]

[ "func", "(", "r", "*", "multiModelRunner", ")", "Run", "(", "transactions", "jujutxn", ".", "TransactionSource", ")", "error", "{", "return", "r", ".", "rawRunner", ".", "Run", "(", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "ops", ",", "err", ":=", "transactions", "(", "attempt", ")", "\n", "if", "err", "!=", "nil", "{", "// Don't use Trace here as jujutxn doens't use juju/errors", "// and won't deal correctly with some returned errors.", "return", "nil", ",", "err", "\n", "}", "\n", "newOps", ",", "err", ":=", "r", ".", "updateOps", "(", "ops", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "newOps", ",", "nil", "\n", "}", ")", "\n", "}" ]

[ "Run", "is", "part", "of", "the", "jujutxn", ".", "Runner", "interface", ".", "Operations", "returned", "by", "the", "given", "transactions", "function", "that", "affect", "multi", "-", "model", "collections", "will", "be", "modified", "to", "ensure", "correct", "interaction", "with", "these", "collections", "." ]

[ "func", "(", "r", "*", "multiModelRunner", ")", "MaybePruneTransactions", "(", "opts", "jujutxn", ".", "PruneOptions", ")", "error", "{", "return", "r", ".", "rawRunner", ".", "MaybePruneTransactions", "(", "opts", ")", "\n", "}" ]

[ "MaybePruneTransactions", "is", "part", "of", "the", "jujutxn", ".", "Runner", "interface", "." ]

[ "func", "(", "r", "*", "multiModelRunner", ")", "mungeUpdate", "(", "updateDoc", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "switch", "doc", ":=", "updateDoc", ".", "(", "type", ")", "{", "case", "bson", ".", "D", ":", "return", "r", ".", "mungeBsonDUpdate", "(", "doc", ")", "\n", "case", "bson", ".", "M", ":", "return", "r", ".", "mungeBsonMUpdate", "(", "doc", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "updateDoc", ")", "\n", "}", "\n", "}" ]

[ "mungeUpdate", "takes", "the", "value", "of", "an", "txn", ".", "Op", "Update", "field", "and", "modifies", "it", "to", "be", "multi", "-", "model", "safe", "returning", "the", "modified", "document", "." ]

[ "func", "NewStatusSetCmd", "(", "ctx", "HookContext", ")", "(", "*", "StatusSetCmd", ",", "error", ")", "{", "return", "&", "StatusSetCmd", "{", "hookContextFunc", ":", "componentHookContext", "(", "ctx", ")", "}", ",", "nil", "\n", "}" ]

[ "NewStatusSetCmd", "returns", "a", "new", "StatusSetCmd", "that", "wraps", "the", "given", "context", "." ]

[ "func", "insertLinkLayerDevicesRefsOp", "(", "modelUUID", ",", "linkLayerDeviceDocID", "string", ")", "txn", ".", "Op", "{", "refsDoc", ":=", "&", "linkLayerDevicesRefsDoc", "{", "DocID", ":", "linkLayerDeviceDocID", ",", "ModelUUID", ":", "modelUUID", ",", "NumChildren", ":", "0", ",", "}", "\n", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesRefsC", ",", "Id", ":", "linkLayerDeviceDocID", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "refsDoc", ",", "}", "\n", "}" ]

[ "insertLinkLayerDevicesRefsOp", "returns", "an", "operation", "to", "insert", "a", "new", "linkLayerDevicesRefsDoc", "for", "the", "given", "modelUUID", "and", "linkLayerDeviceDocID", "with", "NumChildren", "=", "0", "." ]

[ "func", "removeLinkLayerDevicesRefsOp", "(", "linkLayerDeviceDocID", "string", ")", "txn", ".", "Op", "{", "hasNoChildren", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "0", "}", "}", "\n", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesRefsC", ",", "Id", ":", "linkLayerDeviceDocID", ",", "Assert", ":", "hasNoChildren", ",", "Remove", ":", "true", ",", "}", "\n", "}" ]

[ "removeLinkLayerDevicesRefsOp", "returns", "an", "operation", "to", "remove", "the", "linkLayerDevicesRefsDoc", "for", "the", "given", "linkLayerDeviceDocID", "asserting", "the", "document", "has", "NumChildren", "==", "0", "." ]

[ "func", "getParentDeviceNumChildrenRefs", "(", "st", "*", "State", ",", "linkLayerDeviceDocID", "string", ")", "(", "int", ",", "error", ")", "{", "devicesRefs", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "linkLayerDevicesRefsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "doc", "linkLayerDevicesRefsDoc", "\n", "err", ":=", "devicesRefs", ".", "FindId", "(", "linkLayerDeviceDocID", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "-", "1", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "0", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "doc", ".", "NumChildren", ",", "nil", "\n", "}" ]

[ "getParentDeviceNumChildrenRefs", "returns", "the", "NumChildren", "value", "for", "the", "given", "linkLayerDeviceDocID", ".", "If", "the", "linkLayerDevicesRefsDoc", "is", "missing", "no", "error", "and", "-", "1", "children", "are", "returned", "." ]

[ "func", "incrementDeviceNumChildrenOp", "(", "linkLayerDeviceDocID", "string", ")", "txn", ".", "Op", "{", "hasZeroOrMoreChildren", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "0", "}", "}", "}", "}", "\n", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesRefsC", ",", "Id", ":", "linkLayerDeviceDocID", ",", "Assert", ":", "hasZeroOrMoreChildren", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "}", "}", ",", "}", "\n", "}" ]

[ "incrementDeviceNumChildrenOp", "returns", "an", "operation", "that", "increments", "the", "NumChildren", "value", "of", "the", "linkLayerDevicesRefsDoc", "matching", "the", "given", "linkLayerDeviceDocID", "and", "asserting", "the", "document", "has", "NumChildren", ">", "=", "0", "." ]

[ "func", "decrementDeviceNumChildrenOp", "(", "linkLayerDeviceDocID", "string", ")", "txn", ".", "Op", "{", "hasAtLeastOneMoreChild", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "}", "}", "\n", "return", "txn", ".", "Op", "{", "C", ":", "linkLayerDevicesRefsC", ",", "Id", ":", "linkLayerDeviceDocID", ",", "Assert", ":", "hasAtLeastOneMoreChild", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "-", "1", "}", "}", "}", "}", ",", "}", "\n", "}" ]

[ "decrementDeviceNumChildrenOp", "returns", "an", "operation", "that", "decrements", "the", "NumChildren", "value", "of", "the", "linkLayerDevicesRefsDoc", "matching", "the", "given", "linkLayerDeviceDocID", "and", "asserting", "the", "document", "has", "NumChildren", ">", "=", "1", "." ]

[ "func", "(", "c", "*", "Client", ")", "Offer", "(", "modelUUID", ",", "application", "string", ",", "endpoints", "[", "]", "string", ",", "offerName", "string", ",", "desc", "string", ")", "(", "[", "]", "params", ".", "ErrorResult", ",", "error", ")", "{", "// TODO(wallyworld) - support endpoint aliases", "ep", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "name", ":=", "range", "endpoints", "{", "ep", "[", "name", "]", "=", "name", "\n", "}", "\n", "offers", ":=", "[", "]", "params", ".", "AddApplicationOffer", "{", "{", "ModelTag", ":", "names", ".", "NewModelTag", "(", "modelUUID", ")", ".", "String", "(", ")", ",", "ApplicationName", ":", "application", ",", "ApplicationDescription", ":", "desc", ",", "Endpoints", ":", "ep", ",", "OfferName", ":", "offerName", ",", "}", ",", "}", "\n", "out", ":=", "params", ".", "ErrorResults", "{", "}", "\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "params", ".", "AddApplicationOffers", "{", "Offers", ":", "offers", "}", ",", "&", "out", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "out", ".", "Results", ",", "nil", "\n", "}" ]

[ "Offer", "prepares", "application", "s", "endpoints", "for", "consumption", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListOffers", "(", "filters", "...", "crossmodel", ".", "ApplicationOfferFilter", ")", "(", "[", "]", "*", "crossmodel", ".", "ApplicationOfferDetails", ",", "error", ")", "{", "var", "paramsFilter", "params", ".", "OfferFilters", "\n", "for", "_", ",", "f", ":=", "range", "filters", "{", "filterTerm", ":=", "params", ".", "OfferFilter", "{", "OwnerName", ":", "f", ".", "OwnerName", ",", "ModelName", ":", "f", ".", "ModelName", ",", "OfferName", ":", "f", ".", "OfferName", ",", "ApplicationName", ":", "f", ".", "ApplicationName", ",", "Endpoints", ":", "make", "(", "[", "]", "params", ".", "EndpointFilterAttributes", ",", "len", "(", "f", ".", "Endpoints", ")", ")", ",", "AllowedConsumerTags", ":", "make", "(", "[", "]", "string", ",", "len", "(", "f", ".", "AllowedConsumers", ")", ")", ",", "ConnectedUserTags", ":", "make", "(", "[", "]", "string", ",", "len", "(", "f", ".", "ConnectedUsers", ")", ")", ",", "}", "\n", "for", "i", ",", "ep", ":=", "range", "f", ".", "Endpoints", "{", "filterTerm", ".", "Endpoints", "[", "i", "]", ".", "Name", "=", "ep", ".", "Name", "\n", "filterTerm", ".", "Endpoints", "[", "i", "]", ".", "Interface", "=", "ep", ".", "Interface", "\n", "filterTerm", ".", "Endpoints", "[", "i", "]", ".", "Role", "=", "ep", ".", "Role", "\n", "}", "\n", "for", "i", ",", "u", ":=", "range", "f", ".", "AllowedConsumers", "{", "filterTerm", ".", "AllowedConsumerTags", "[", "i", "]", "=", "names", ".", "NewUserTag", "(", "u", ")", ".", "String", "(", ")", "\n", "}", "\n", "for", "i", ",", "u", ":=", "range", "f", ".", "ConnectedUsers", "{", "filterTerm", ".", "ConnectedUserTags", "[", "i", "]", "=", "names", ".", "NewUserTag", "(", "u", ")", ".", "String", "(", ")", "\n", "}", "\n", "paramsFilter", ".", "Filters", "=", "append", "(", "paramsFilter", ".", "Filters", ",", "filterTerm", ")", "\n", "}", "\n\n", "offers", ":=", "params", ".", "QueryApplicationOffersResults", "{", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "paramsFilter", ",", "&", "offers", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "convertOffersResultsToModel", "(", "offers", ".", "Results", ")", "\n", "}" ]

[ "ListOffers", "gets", "all", "remote", "applications", "that", "have", "been", "offered", "from", "this", "Juju", "model", ".", "Each", "returned", "application", "satisfies", "at", "least", "one", "of", "the", "the", "specified", "filters", "." ]

[ "func", "(", "c", "*", "Client", ")", "GrantOffer", "(", "user", ",", "access", "string", ",", "offerURLs", "...", "string", ")", "error", "{", "return", "c", ".", "modifyOfferUser", "(", "params", ".", "GrantOfferAccess", ",", "user", ",", "access", ",", "offerURLs", ")", "\n", "}" ]

[ "GrantOffer", "grants", "a", "user", "access", "to", "the", "specified", "offers", "." ]

[ "func", "(", "c", "*", "Client", ")", "RevokeOffer", "(", "user", ",", "access", "string", ",", "offerURLs", "...", "string", ")", "error", "{", "return", "c", ".", "modifyOfferUser", "(", "params", ".", "RevokeOfferAccess", ",", "user", ",", "access", ",", "offerURLs", ")", "\n", "}" ]

[ "RevokeOffer", "revokes", "a", "user", "s", "access", "to", "the", "specified", "offers", "." ]

[ "func", "(", "c", "*", "Client", ")", "ApplicationOffer", "(", "urlStr", "string", ")", "(", "*", "crossmodel", ".", "ApplicationOfferDetails", ",", "error", ")", "{", "url", ",", "err", ":=", "crossmodel", ".", "ParseOfferURL", "(", "urlStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "url", ".", "Source", "!=", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "found", ":=", "params", ".", "ApplicationOffersResults", "{", "}", "\n\n", "err", "=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "params", ".", "OfferURLs", "{", "[", "]", "string", "{", "urlStr", "}", "}", ",", "&", "found", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "result", ":=", "found", ".", "Results", "\n", "if", "len", "(", "result", ")", "!=", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "len", "(", "result", ")", ")", "\n", "}", "\n\n", "theOne", ":=", "result", "[", "0", "]", "\n", "if", "theOne", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "theOne", ".", "Error", ")", "\n", "}", "\n", "return", "offerParamsToDetails", "(", "*", "theOne", ".", "Result", ")", "\n", "}" ]

[ "ApplicationOffer", "returns", "offered", "remote", "application", "details", "for", "a", "given", "URL", "." ]

[ "func", "(", "c", "*", "Client", ")", "FindApplicationOffers", "(", "filters", "...", "crossmodel", ".", "ApplicationOfferFilter", ")", "(", "[", "]", "*", "crossmodel", ".", "ApplicationOfferDetails", ",", "error", ")", "{", "// We need at least one filter. The default filter will list all local applications.", "if", "len", "(", "filters", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "paramsFilter", "params", ".", "OfferFilters", "\n", "for", "_", ",", "f", ":=", "range", "filters", "{", "filterTerm", ":=", "params", ".", "OfferFilter", "{", "OfferName", ":", "f", ".", "OfferName", ",", "ModelName", ":", "f", ".", "ModelName", ",", "OwnerName", ":", "f", ".", "OwnerName", ",", "}", "\n", "filterTerm", ".", "Endpoints", "=", "make", "(", "[", "]", "params", ".", "EndpointFilterAttributes", ",", "len", "(", "f", ".", "Endpoints", ")", ")", "\n", "for", "i", ",", "ep", ":=", "range", "f", ".", "Endpoints", "{", "filterTerm", ".", "Endpoints", "[", "i", "]", ".", "Name", "=", "ep", ".", "Name", "\n", "filterTerm", ".", "Endpoints", "[", "i", "]", ".", "Interface", "=", "ep", ".", "Interface", "\n", "filterTerm", ".", "Endpoints", "[", "i", "]", ".", "Role", "=", "ep", ".", "Role", "\n", "}", "\n", "paramsFilter", ".", "Filters", "=", "append", "(", "paramsFilter", ".", "Filters", ",", "filterTerm", ")", "\n", "}", "\n\n", "offers", ":=", "params", ".", "QueryApplicationOffersResults", "{", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "paramsFilter", ",", "&", "offers", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "convertOffersResultsToModel", "(", "offers", ".", "Results", ")", "\n", "}" ]

[ "FindApplicationOffers", "returns", "all", "application", "offers", "matching", "the", "supplied", "filter", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetConsumeDetails", "(", "urlStr", "string", ")", "(", "params", ".", "ConsumeOfferDetails", ",", "error", ")", "{", "url", ",", "err", ":=", "crossmodel", ".", "ParseOfferURL", "(", "urlStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ConsumeOfferDetails", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "url", ".", "Source", "!=", "\"", "\"", "{", "return", "params", ".", "ConsumeOfferDetails", "{", "}", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "found", ":=", "params", ".", "ConsumeOfferDetailsResults", "{", "}", "\n\n", "err", "=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "params", ".", "OfferURLs", "{", "[", "]", "string", "{", "urlStr", "}", "}", ",", "&", "found", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ConsumeOfferDetails", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "result", ":=", "found", ".", "Results", "\n", "if", "len", "(", "result", ")", "!=", "1", "{", "return", "params", ".", "ConsumeOfferDetails", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "len", "(", "result", ")", ")", "\n", "}", "\n\n", "theOne", ":=", "result", "[", "0", "]", "\n", "if", "theOne", ".", "Error", "!=", "nil", "{", "return", "params", ".", "ConsumeOfferDetails", "{", "}", ",", "errors", ".", "Trace", "(", "theOne", ".", "Error", ")", "\n", "}", "\n", "return", "params", ".", "ConsumeOfferDetails", "{", "Offer", ":", "theOne", ".", "Offer", ",", "Macaroon", ":", "theOne", ".", "Macaroon", ",", "ControllerInfo", ":", "theOne", ".", "ControllerInfo", ",", "}", ",", "nil", "\n", "}" ]

[ "GetConsumeDetails", "returns", "details", "necessary", "to", "consue", "an", "offer", "at", "a", "given", "URL", "." ]

[ "func", "(", "c", "*", "Client", ")", "DestroyOffers", "(", "force", "bool", ",", "offerURLs", "...", "string", ")", "error", "{", "if", "len", "(", "offerURLs", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "if", "force", "{", "if", "bestVer", ":=", "c", ".", "BestAPIVersion", "(", ")", ";", "bestVer", "<", "2", "{", "return", "errors", ".", "NotImplementedf", "(", "\"", "\"", ",", "bestVer", ")", "\n", "}", "\n", "}", "\n", "args", ":=", "params", ".", "DestroyApplicationOffers", "{", "Force", ":", "force", ",", "OfferURLs", ":", "make", "(", "[", "]", "string", ",", "len", "(", "offerURLs", ")", ")", ",", "}", "\n", "for", "i", ",", "url", ":=", "range", "offerURLs", "{", "if", "_", ",", "err", ":=", "crossmodel", ".", "ParseOfferURL", "(", "url", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "args", ".", "OfferURLs", "[", "i", "]", "=", "url", "\n", "}", "\n\n", "var", "result", "params", ".", "ErrorResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "result", ".", "Results", ")", "!=", "len", "(", "args", ".", "OfferURLs", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "args", ".", "OfferURLs", ")", ",", "len", "(", "result", ".", "Results", ")", ")", "\n", "}", "\n", "return", "result", ".", "Combine", "(", ")", "\n", "}" ]

[ "DestroyOffers", "removes", "the", "specified", "application", "offers", "." ]

[ "func", "NewClient", "(", "caller", "base", ".", "APICaller", ")", "leadership", ".", "Claimer", "{", "return", "&", "client", "{", "base", ".", "NewFacadeCaller", "(", "caller", ",", "\"", "\"", ")", "}", "\n", "}" ]

[ "NewClient", "returns", "a", "new", "leadership", ".", "Claimer", "backed", "by", "the", "supplied", "api", "caller", "." ]