Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.3k

[ "func", "(", "c", "*", "Client", ")", "Import", "(", "bytes", "[", "]", "byte", ")", "error", "{", "serialized", ":=", "params", ".", "SerializedModel", "{", "Bytes", ":", "bytes", "}", "\n", "return", "c", ".", "caller", ".", "FacadeCall", "(", "\"", "\"", ",", "serialized", ",", "nil", ")", "\n", "}" ]

[ "Import", "takes", "a", "serialized", "model", "and", "imports", "it", "into", "the", "target", "controller", "." ]

[ "func", "(", "c", "*", "Client", ")", "Abort", "(", "modelUUID", "string", ")", "error", "{", "args", ":=", "params", ".", "ModelArgs", "{", "ModelTag", ":", "names", ".", "NewModelTag", "(", "modelUUID", ")", ".", "String", "(", ")", "}", "\n", "return", "c", ".", "caller", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "}" ]

[ "Abort", "removes", "all", "data", "relating", "to", "a", "previously", "imported", "model", "." ]

[ "func", "(", "c", "*", "Client", ")", "UploadTools", "(", "modelUUID", "string", ",", "r", "io", ".", "ReadSeeker", ",", "vers", "version", ".", "Binary", ",", "additionalSeries", "...", "string", ")", "(", "tools", ".", "List", ",", "error", ")", "{", "endpoint", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "vers", ",", "strings", ".", "Join", "(", "additionalSeries", ",", "\"", "\"", ")", ")", "\n", "contentType", ":=", "\"", "\"", "\n", "var", "resp", "params", ".", "ToolsResult", "\n", "if", "err", ":=", "c", ".", "httpPost", "(", "modelUUID", ",", "r", ",", "endpoint", ",", "contentType", ",", "&", "resp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "ToolsList", ",", "nil", "\n", "}" ]

[ "UploadTools", "uploads", "tools", "at", "the", "specified", "location", "to", "the", "API", "server", "over", "HTTPS", "for", "the", "specified", "model", "." ]

[ "func", "(", "c", "*", "Client", ")", "UploadResource", "(", "modelUUID", "string", ",", "res", "resource", ".", "Resource", ",", "r", "io", ".", "ReadSeeker", ")", "error", "{", "args", ":=", "makeResourceArgs", "(", "res", ")", "\n", "args", ".", "Add", "(", "\"", "\"", ",", "res", ".", "ApplicationID", ")", "\n", "err", ":=", "c", ".", "resourcePost", "(", "modelUUID", ",", "args", ",", "r", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "UploadResource", "uploads", "a", "resource", "to", "the", "migration", "endpoint", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetUnitResource", "(", "modelUUID", ",", "unit", "string", ",", "res", "resource", ".", "Resource", ")", "error", "{", "args", ":=", "makeResourceArgs", "(", "res", ")", "\n", "args", ".", "Add", "(", "\"", "\"", ",", "unit", ")", "\n", "err", ":=", "c", ".", "resourcePost", "(", "modelUUID", ",", "args", ",", "nil", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "SetUnitResource", "sets", "the", "metadata", "for", "a", "particular", "unit", "resource", "." ]

[ "func", "(", "c", "*", "Client", ")", "OpenLogTransferStream", "(", "modelUUID", "string", ")", "(", "base", ".", "Stream", ",", "error", ")", "{", "attrs", ":=", "url", ".", "Values", "{", "}", "\n", "attrs", ".", "Set", "(", "\"", "\"", ",", "jujuversion", ".", "Current", ".", "String", "(", ")", ")", "\n", "headers", ":=", "http", ".", "Header", "{", "}", "\n", "headers", ".", "Set", "(", "params", ".", "MigrationModelHTTPHeader", ",", "modelUUID", ")", "\n", "caller", ":=", "c", ".", "caller", ".", "RawAPICaller", "(", ")", "\n", "stream", ",", "err", ":=", "caller", ".", "ConnectControllerStream", "(", "\"", "\"", ",", "attrs", ",", "headers", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "stream", ",", "nil", "\n", "}" ]

[ "OpenLogTransferStream", "connects", "to", "the", "migration", "logtransfer", "endpoint", "on", "the", "target", "controller", "and", "returns", "a", "stream", "that", "JSON", "logs", "records", "can", "be", "fed", "into", ".", "The", "objects", "written", "should", "be", "params", ".", "LogRecords", "." ]

[ "func", "(", "c", "*", "Client", ")", "CACert", "(", ")", "(", "string", ",", "error", ")", "{", "var", "result", "params", ".", "BytesResult", "\n", "err", ":=", "c", ".", "caller", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "string", "(", "result", ".", "Result", ")", ",", "nil", "\n", "}" ]

[ "CACert", "returns", "the", "CA", "certificate", "associated", "with", "the", "connection", "." ]

[ "func", "(", "u", "*", "Unit", ")", "Name", "(", ")", "string", "{", "u", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "u", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "u", ".", "details", ".", "Name", "\n", "}" ]

[ "Name", "returns", "the", "name", "of", "this", "unit", "." ]

[ "func", "(", "u", "*", "Unit", ")", "Application", "(", ")", "string", "{", "u", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "u", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "u", ".", "details", ".", "Application", "\n", "}" ]

[ "Application", "returns", "the", "application", "name", "of", "this", "unit", "." ]

[ "func", "(", "u", "*", "Unit", ")", "MachineId", "(", ")", "string", "{", "u", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "u", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "u", ".", "details", ".", "MachineId", "\n", "}" ]

[ "MachineId", "returns", "the", "ID", "of", "the", "machine", "hosting", "this", "unit", "." ]

[ "func", "(", "u", "*", "Unit", ")", "Subordinate", "(", ")", "bool", "{", "u", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "u", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "u", ".", "details", ".", "Subordinate", "\n", "}" ]

[ "Subordinate", "returns", "a", "bool", "indicating", "whether", "this", "unit", "is", "a", "subordinate", "." ]

[ "func", "(", "u", "*", "Unit", ")", "Principal", "(", ")", "string", "{", "u", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "u", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "u", ".", "details", ".", "Principal", "\n", "}" ]

[ "Principal", "returns", "the", "name", "of", "the", "principal", "unit", "for", "the", "same", "application", "." ]

[ "func", "(", "u", "*", "Unit", ")", "CharmURL", "(", ")", "string", "{", "u", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "u", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "u", ".", "details", ".", "CharmURL", "\n", "}" ]

[ "CharmURL", "returns", "the", "charm", "URL", "for", "this", "unit", "s", "application", "." ]

[ "func", "(", "result", "ErrorResults", ")", "OneError", "(", ")", "error", "{", "if", "n", ":=", "len", "(", "result", ".", "Results", ")", ";", "n", "!=", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "if", "err", ":=", "result", ".", "Results", "[", "0", "]", ".", "Error", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "OneError", "returns", "the", "error", "from", "the", "result", "of", "a", "bulk", "operation", "on", "a", "single", "value", "." ]

[ "func", "(", "result", "ErrorResults", ")", "Combine", "(", ")", "error", "{", "var", "errorStrings", "[", "]", "string", "\n", "for", "_", ",", "r", ":=", "range", "result", ".", "Results", "{", "if", "r", ".", "Error", "!=", "nil", "{", "errorStrings", "=", "append", "(", "errorStrings", ",", "r", ".", "Error", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "errorStrings", "!=", "nil", "{", "return", "errors", ".", "New", "(", "strings", ".", "Join", "(", "errorStrings", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Combine", "returns", "one", "error", "from", "the", "result", "which", "is", "an", "accumulation", "of", "the", "errors", ".", "If", "there", "are", "no", "errors", "in", "the", "result", "the", "return", "value", "is", "nil", ".", "Otherwise", "the", "error", "values", "are", "combined", "with", "new", "-", "line", "characters", "." ]

[ "func", "NewPublicFacade", "(", "st", "*", "state", ".", "State", ",", "_", "facade", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ")", "(", "*", "Facade", ",", "error", ")", "{", "if", "!", "authorizer", ".", "AuthClient", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n\n", "rst", ",", "err", ":=", "st", ".", "Resources", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "controllerCfg", ",", "err", ":=", "st", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "newClient", ":=", "func", "(", ")", "(", "CharmStore", ",", "error", ")", "{", "return", "charmstore", ".", "NewCachingClient", "(", "state", ".", "MacaroonCache", "{", "st", "}", ",", "controllerCfg", ".", "CharmStoreURL", "(", ")", ")", "\n", "}", "\n", "facade", ",", "err", ":=", "NewFacade", "(", "rst", ",", "newClient", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "facade", ",", "nil", "\n", "}" ]

[ "NewPublicFacade", "creates", "a", "public", "API", "facade", "for", "resources", ".", "It", "is", "used", "for", "API", "registration", "." ]

[ "func", "NewFacade", "(", "store", "Backend", ",", "newClient", "func", "(", ")", "(", "CharmStore", ",", "error", ")", ")", "(", "*", "Facade", ",", "error", ")", "{", "if", "store", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "newClient", "==", "nil", "{", "// Technically this only matters for one code path through", "// AddPendingResources(). However, that functionality should be", "// provided. So we indicate the problem here instead of later", "// in the specific place where it actually matters.", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "f", ":=", "&", "Facade", "{", "store", ":", "store", ",", "newCharmstoreClient", ":", "newClient", ",", "}", "\n", "return", "f", ",", "nil", "\n", "}" ]

[ "NewFacade", "returns", "a", "new", "resoures", "API", "facade", "." ]

[ "func", "(", "f", "Facade", ")", "ListResources", "(", "args", "params", ".", "ListResourcesArgs", ")", "(", "params", ".", "ResourcesResults", ",", "error", ")", "{", "var", "r", "params", ".", "ResourcesResults", "\n", "r", ".", "Results", "=", "make", "(", "[", "]", "params", ".", "ResourcesResult", ",", "len", "(", "args", ".", "Entities", ")", ")", "\n\n", "for", "i", ",", "e", ":=", "range", "args", ".", "Entities", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "e", ".", "Tag", ")", "\n", "tag", ",", "apierr", ":=", "parseApplicationTag", "(", "e", ".", "Tag", ")", "\n", "if", "apierr", "!=", "nil", "{", "r", ".", "Results", "[", "i", "]", "=", "params", ".", "ResourcesResult", "{", "ErrorResult", ":", "params", ".", "ErrorResult", "{", "Error", ":", "apierr", ",", "}", ",", "}", "\n", "continue", "\n", "}", "\n\n", "svcRes", ",", "err", ":=", "f", ".", "store", ".", "ListResources", "(", "tag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "Results", "[", "i", "]", "=", "errorResult", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "r", ".", "Results", "[", "i", "]", "=", "api", ".", "ApplicationResources2APIResult", "(", "svcRes", ")", "\n", "}", "\n", "return", "r", ",", "nil", "\n", "}" ]

[ "ListResources", "returns", "the", "list", "of", "resources", "for", "the", "given", "application", "." ]

[ "func", "(", "f", "Facade", ")", "resourcesFromCharmstore", "(", "charms", "[", "]", "charmstore", ".", "CharmID", ",", "client", "CharmStore", ")", "(", "map", "[", "string", "]", "charmresource", ".", "Resource", ",", "error", ")", "{", "results", ",", "err", ":=", "client", ".", "ListResources", "(", "charms", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "storeResources", ":=", "make", "(", "map", "[", "string", "]", "charmresource", ".", "Resource", ")", "\n", "if", "len", "(", "results", ")", "!=", "0", "{", "for", "_", ",", "res", ":=", "range", "results", "[", "0", "]", "{", "storeResources", "[", "res", ".", "Name", "]", "=", "res", "\n", "}", "\n", "}", "\n", "return", "storeResources", ",", "nil", "\n", "}" ]

[ "resourcesFromCharmstore", "gets", "the", "info", "for", "the", "charm", "s", "resources", "in", "the", "charm", "store", ".", "If", "the", "charm", "URL", "has", "a", "revision", "then", "that", "revision", "s", "resources", "are", "returned", ".", "Otherwise", "the", "latest", "info", "for", "each", "of", "the", "resources", "is", "returned", "." ]

[ "func", "resolveStoreResource", "(", "res", "charmresource", ".", "Resource", ",", "storeResources", "map", "[", "string", "]", "charmresource", ".", "Resource", ",", "id", "charmstore", ".", "CharmID", ",", "client", "CharmStore", ")", "(", "charmresource", ".", "Resource", ",", "error", ")", "{", "storeRes", ",", "ok", ":=", "storeResources", "[", "res", ".", "Name", "]", "\n", "if", "!", "ok", "{", "// This indicates that AddPendingResources() was called for", "// a resource the charm store doesn't know about (for the", "// relevant charm revision).", "// TODO(ericsnow) Do the following once the charm store supports", "// the necessary endpoints:", "// return res, errors.NotFoundf(\"charm store resource %q\", res.Name)", "return", "res", ",", "nil", "\n", "}", "\n\n", "if", "res", ".", "Revision", "<", "0", "{", "// The caller wants to use the charm store info.", "return", "storeRes", ",", "nil", "\n", "}", "\n", "if", "res", ".", "Revision", "==", "storeRes", ".", "Revision", "{", "// We don't worry about if they otherwise match. Only the", "// revision is significant here. So we use the info from the", "// charm store since it is authoritative.", "return", "storeRes", ",", "nil", "\n", "}", "\n", "if", "res", ".", "Fingerprint", ".", "IsZero", "(", ")", "{", "// The caller wants resource info from the charm store, but with", "// a different resource revision than the one associated with", "// the charm in the store.", "req", ":=", "charmstore", ".", "ResourceRequest", "{", "Charm", ":", "id", ".", "URL", ",", "Channel", ":", "id", ".", "Channel", ",", "Name", ":", "res", ".", "Name", ",", "Revision", ":", "res", ".", "Revision", ",", "}", "\n", "storeRes", ",", "err", ":=", "client", ".", "ResourceInfo", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "storeRes", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "storeRes", ",", "nil", "\n", "}", "\n", "// The caller fully-specified a resource with a different resource", "// revision than the one associated with the charm in the store. So", "// we use the provided info as-is.", "return", "res", ",", "nil", "\n", "}" ]

[ "resolveStoreResource", "selects", "the", "resource", "info", "to", "use", ".", "It", "decides", "between", "the", "provided", "and", "latest", "info", "based", "on", "the", "revision", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "ecfg", "(", ")", "*", "maasModelConfig", "{", "env", ".", "ecfgMutex", ".", "Lock", "(", ")", "\n", "cfg", ":=", "*", "env", ".", "ecfgUnlocked", "\n", "env", ".", "ecfgMutex", ".", "Unlock", "(", ")", "\n", "return", "&", "cfg", "\n", "}" ]

[ "ecfg", "returns", "the", "environment", "s", "maasModelConfig", "and", "protects", "it", "with", "a", "mutex", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "allArchitectures2", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "string", ",", "error", ")", "{", "resources", ",", "err", ":=", "env", ".", "maasController", ".", "BootResources", "(", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "architectures", ":=", "set", ".", "NewStrings", "(", ")", "\n", "for", "_", ",", "resource", ":=", "range", "resources", "{", "architectures", ".", "Add", "(", "strings", ".", "Split", "(", "resource", ".", "Architecture", "(", ")", ",", "\"", "\"", ")", "[", "0", "]", ")", "\n", "}", "\n", "return", "architectures", ".", "SortedValues", "(", ")", ",", "nil", "\n", "}" ]

[ "allArchitectures2", "uses", "the", "MAAS2", "controller", "to", "get", "architectures", "from", "boot", "resources", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "allArchitecturesWithFallback", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "string", ",", "error", ")", "{", "architectures", ",", "err", ":=", "env", ".", "allArchitectures", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "||", "len", "(", "architectures", ")", "==", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "architectures", ",", "err", ":=", "env", ".", "nodeArchitectures", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "architectures", ",", "nil", "\n", "}", "else", "{", "return", "architectures", ",", "nil", "\n", "}", "\n", "}" ]

[ "allArchitectureWithFallback", "queries", "MAAS", "for", "all", "of", "the", "boot", "-", "images", "across", "all", "registered", "nodegroups", "and", "collapses", "them", "down", "to", "unique", "architectures", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "getNodegroups", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "string", ",", "error", ")", "{", "nodegroupsListing", ":=", "env", ".", "getMAASClient", "(", ")", ".", "GetSubObject", "(", "\"", "\"", ")", "\n", "nodegroupsResult", ",", "err", ":=", "nodegroupsListing", ".", "CallGet", "(", "\"", "\"", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "list", ",", "err", ":=", "nodegroupsResult", ".", "GetArray", "(", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "nodegroups", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "list", ")", ")", "\n", "for", "i", ",", "obj", ":=", "range", "list", "{", "nodegroup", ",", "err", ":=", "obj", ".", "GetMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "uuid", ",", "err", ":=", "nodegroup", "[", "\"", "\"", "]", ".", "GetString", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "nodegroups", "[", "i", "]", "=", "uuid", "\n", "}", "\n", "return", "nodegroups", ",", "nil", "\n", "}" ]

[ "getNodegroups", "returns", "the", "UUID", "corresponding", "to", "each", "nodegroup", "in", "the", "MAAS", "installation", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "nodegroupBootImages", "(", "ctx", "context", ".", "ProviderCallContext", ",", "nodegroupUUID", "string", ")", "(", "[", "]", "bootImage", ",", "error", ")", "{", "nodegroupObject", ":=", "env", ".", "getMAASClient", "(", ")", ".", "GetSubObject", "(", "\"", "\"", ")", ".", "GetSubObject", "(", "nodegroupUUID", ")", "\n", "bootImagesObject", ":=", "nodegroupObject", ".", "GetSubObject", "(", "\"", "\"", ")", "\n", "result", ",", "err", ":=", "bootImagesObject", ".", "CallGet", "(", "\"", "\"", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "list", ",", "err", ":=", "result", ".", "GetArray", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "bootImages", "[", "]", "bootImage", "\n", "for", "_", ",", "obj", ":=", "range", "list", "{", "bootimage", ",", "err", ":=", "obj", ".", "GetMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "arch", ",", "err", ":=", "bootimage", "[", "\"", "\"", "]", ".", "GetString", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "release", ",", "err", ":=", "bootimage", "[", "\"", "\"", "]", ".", "GetString", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "bootImages", "=", "append", "(", "bootImages", ",", "bootImage", "{", "architecture", ":", "arch", ",", "release", ":", "release", ",", "}", ")", "\n", "}", "\n", "return", "bootImages", ",", "nil", "\n", "}" ]

[ "nodegroupBootImages", "returns", "the", "set", "of", "boot", "-", "images", "for", "the", "specified", "nodegroup", "." ]

[ "func", "getCapabilities", "(", "client", "*", "gomaasapi", ".", "MAASObject", ",", "serverURL", "string", ")", "(", "set", ".", "Strings", ",", "error", ")", "{", "caps", ":=", "make", "(", "set", ".", "Strings", ")", "\n", "var", "result", "gomaasapi", ".", "JSONObject", "\n", "var", "err", "error", "\n\n", "for", "a", ":=", "shortAttempt", ".", "Start", "(", ")", ";", "a", ".", "Next", "(", ")", ";", "{", "version", ":=", "client", ".", "GetSubObject", "(", "\"", "\"", ")", "\n", "result", ",", "err", "=", "version", ".", "CallGet", "(", "\"", "\"", ",", "nil", ")", "\n", "if", "err", "==", "nil", "{", "break", "\n", "}", "\n", "if", "err", ",", "ok", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "gomaasapi", ".", "ServerError", ")", ";", "ok", "&&", "err", ".", "StatusCode", "==", "404", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "serverURL", ",", "err", ")", "\n\n", "message", ":=", "\"", "\"", "\n", "trimmedURL", ":=", "strings", ".", "TrimRight", "(", "serverURL", ",", "\"", "\"", ")", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "trimmedURL", ",", "\"", "\"", ")", "{", "message", "+=", "\"", "\"", "\n", "}", "\n", "return", "caps", ",", "errors", ".", "NewNotSupported", "(", "nil", ",", "message", ")", "\n", "}", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "serverURL", ",", "err", ")", "\n", "return", "caps", ",", "err", "\n", "}", "\n", "info", ",", "err", ":=", "result", ".", "GetMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "serverURL", ",", "err", ")", "\n", "// invalid data of some sort, probably not a MAAS server.", "return", "caps", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "capsObj", ",", "ok", ":=", "info", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "caps", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "items", ",", "err", ":=", "capsObj", ".", "GetArray", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "serverURL", ",", "err", ")", "\n", "return", "caps", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "item", ":=", "range", "items", "{", "val", ",", "err", ":=", "item", ".", "GetString", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "serverURL", ",", "err", ")", "\n", "return", "set", ".", "NewStrings", "(", ")", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "caps", ".", "Add", "(", "val", ")", "\n", "}", "\n", "return", "caps", ",", "nil", "\n", "}" ]

[ "getCapabilities", "asks", "the", "MAAS", "server", "for", "its", "capabilities", "if", "supported", "by", "the", "server", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "getMAASClient", "(", ")", "*", "gomaasapi", ".", "MAASObject", "{", "env", ".", "ecfgMutex", ".", "Lock", "(", ")", "\n", "defer", "env", ".", "ecfgMutex", ".", "Unlock", "(", ")", "\n\n", "return", "env", ".", "maasClientUnlocked", "\n", "}" ]

[ "getMAASClient", "returns", "a", "MAAS", "client", "object", "to", "use", "for", "a", "request", "in", "a", "lock", "-", "protected", "fashion", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "acquireNode2", "(", "ctx", "context", ".", "ProviderCallContext", ",", "nodeName", ",", "zoneName", ",", "systemId", "string", ",", "cons", "constraints", ".", "Value", ",", "interfaces", "[", "]", "interfaceBinding", ",", "volumes", "[", "]", "volumeInfo", ",", ")", "(", "maasInstance", ",", "error", ")", "{", "acquireParams", ":=", "convertConstraints2", "(", "cons", ")", "\n", "positiveSpaceNames", ",", "negativeSpaceNames", ":=", "convertSpacesFromConstraints", "(", "cons", ".", "Spaces", ")", "\n", "positiveSpaces", ",", "negativeSpaces", ",", "err", ":=", "env", ".", "spaceNamesToSpaceInfo", "(", "ctx", ",", "positiveSpaceNames", ",", "negativeSpaceNames", ")", "\n", "// If spaces aren't supported the constraints should be empty anyway.", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotSupported", "(", "err", ")", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "err", "=", "addInterfaces2", "(", "&", "acquireParams", ",", "interfaces", ",", "positiveSpaces", ",", "negativeSpaces", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "addStorage2", "(", "&", "acquireParams", ",", "volumes", ")", "\n", "acquireParams", ".", "AgentName", "=", "env", ".", "uuid", "\n", "if", "zoneName", "!=", "\"", "\"", "{", "acquireParams", ".", "Zone", "=", "zoneName", "\n", "}", "\n", "if", "nodeName", "!=", "\"", "\"", "{", "acquireParams", ".", "Hostname", "=", "nodeName", "\n", "}", "\n", "if", "systemId", "!=", "\"", "\"", "{", "acquireParams", ".", "SystemId", "=", "systemId", "\n", "}", "\n", "machine", ",", "constraintMatches", ",", "err", ":=", "env", ".", "maasController", ".", "AllocateMachine", "(", "acquireParams", ")", "\n\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "maas2Instance", "{", "machine", ":", "machine", ",", "constraintMatches", ":", "constraintMatches", ",", "environ", ":", "env", ",", "}", ",", "nil", "\n", "}" ]

[ "acquireNode2", "allocates", "a", "machine", "from", "MAAS2", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "acquireNode", "(", "ctx", "context", ".", "ProviderCallContext", ",", "nodeName", ",", "zoneName", ",", "systemId", "string", ",", "cons", "constraints", ".", "Value", ",", "interfaces", "[", "]", "interfaceBinding", ",", "volumes", "[", "]", "volumeInfo", ",", ")", "(", "gomaasapi", ".", "MAASObject", ",", "error", ")", "{", "// TODO(axw) 2014-08-18 #1358219", "// We should be requesting preferred architectures if unspecified,", "// like in the other providers.", "//", "// This is slightly complicated in MAAS as there are a finite", "// number of each architecture; preference may also conflict with", "// other constraints, such as tags. Thus, a preference becomes a", "// demand (which may fail) if not handled properly.", "acquireParams", ":=", "convertConstraints", "(", "cons", ")", "\n", "positiveSpaceNames", ",", "negativeSpaceNames", ":=", "convertSpacesFromConstraints", "(", "cons", ".", "Spaces", ")", "\n", "positiveSpaces", ",", "negativeSpaces", ",", "err", ":=", "env", ".", "spaceNamesToSpaceInfo", "(", "ctx", ",", "positiveSpaceNames", ",", "negativeSpaceNames", ")", "\n", "// If spaces aren't supported the constraints should be empty anyway.", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotSupported", "(", "err", ")", "{", "return", "gomaasapi", ".", "MAASObject", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "err", "=", "addInterfaces", "(", "acquireParams", ",", "interfaces", ",", "positiveSpaces", ",", "negativeSpaces", ")", "\n", "if", "err", "!=", "nil", "{", "return", "gomaasapi", ".", "MAASObject", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "addStorage", "(", "acquireParams", ",", "volumes", ")", "\n", "acquireParams", ".", "Add", "(", "\"", "\"", ",", "env", ".", "uuid", ")", "\n", "if", "zoneName", "!=", "\"", "\"", "{", "acquireParams", ".", "Add", "(", "\"", "\"", ",", "zoneName", ")", "\n", "}", "\n", "if", "nodeName", "!=", "\"", "\"", "{", "acquireParams", ".", "Add", "(", "\"", "\"", ",", "nodeName", ")", "\n", "}", "\n", "if", "systemId", "!=", "\"", "\"", "{", "acquireParams", ".", "Add", "(", "\"", "\"", ",", "systemId", ")", "\n", "}", "\n\n", "var", "result", "gomaasapi", ".", "JSONObject", "\n", "for", "a", ":=", "shortAttempt", ".", "Start", "(", ")", ";", "a", ".", "Next", "(", ")", ";", "{", "client", ":=", "env", ".", "getMAASClient", "(", ")", ".", "GetSubObject", "(", "\"", "\"", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "acquireParams", ")", "\n", "result", ",", "err", "=", "client", ".", "CallPost", "(", "\"", "\"", ",", "acquireParams", ")", "\n", "if", "err", "==", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "gomaasapi", ".", "MAASObject", "{", "}", ",", "err", "\n", "}", "\n", "node", ",", "err", ":=", "result", ".", "GetMAASObject", "(", ")", "\n", "if", "err", "!=", "nil", "{", "err", ":=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "return", "gomaasapi", ".", "MAASObject", "{", "}", ",", "err", "\n", "}", "\n", "return", "node", ",", "nil", "\n", "}" ]

[ "acquireNode", "allocates", "a", "node", "from", "the", "MAAS", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "startNode", "(", "node", "gomaasapi", ".", "MAASObject", ",", "series", "string", ",", "userdata", "[", "]", "byte", ")", "(", "*", "gomaasapi", ".", "MAASObject", ",", "error", ")", "{", "params", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "series", "}", ",", "\"", "\"", ":", "{", "string", "(", "userdata", ")", "}", ",", "}", "\n", "// Initialize err to a non-nil value as a sentinel for the following", "// loop.", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "var", "result", "gomaasapi", ".", "JSONObject", "\n", "for", "a", ":=", "shortAttempt", ".", "Start", "(", ")", ";", "a", ".", "Next", "(", ")", "&&", "err", "!=", "nil", ";", "{", "result", ",", "err", "=", "node", ".", "CallPost", "(", "\"", "\"", ",", "params", ")", "\n", "if", "err", "==", "nil", "{", "break", "\n", "}", "\n", "}", "\n\n", "if", "err", "==", "nil", "{", "var", "startedNode", "gomaasapi", ".", "MAASObject", "\n", "startedNode", ",", "err", "=", "result", ".", "GetMAASObject", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "startedNode", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}" ]

[ "startNode", "installs", "and", "boots", "a", "node", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "newCloudinitConfig", "(", "hostname", ",", "forSeries", "string", ")", "(", "cloudinit", ".", "CloudConfig", ",", "error", ")", "{", "cloudcfg", ",", "err", ":=", "cloudinit", ".", "New", "(", "forSeries", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "info", ":=", "machineInfo", "{", "hostname", "}", "\n", "runCmd", ",", "err", ":=", "info", ".", "cloudinitRunCmd", "(", "cloudcfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "operatingSystem", ",", "err", ":=", "series", ".", "GetOSFromSeries", "(", "forSeries", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "switch", "operatingSystem", "{", "case", "os", ".", "Windows", ":", "cloudcfg", ".", "AddScripts", "(", "runCmd", ")", "\n", "case", "os", ".", "Ubuntu", ":", "cloudcfg", ".", "SetSystemUpdate", "(", "true", ")", "\n", "cloudcfg", ".", "AddScripts", "(", "\"", "\"", ",", "runCmd", ")", "\n", "// DisableNetworkManagement can still disable the bridge(s) creation.", "if", "on", ",", "set", ":=", "env", ".", "Config", "(", ")", ".", "DisableNetworkManagement", "(", ")", ";", "on", "&&", "set", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "instancecfg", ".", "DefaultBridgeName", ",", ")", "\n", "break", "\n", "}", "\n", "cloudcfg", ".", "AddPackage", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "cloudcfg", ",", "nil", "\n", "}" ]

[ "newCloudinitConfig", "creates", "a", "cloudinit", ".", "Config", "structure", "suitable", "as", "a", "base", "for", "initialising", "a", "MAAS", "node", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "Instances", "(", "ctx", "context", ".", "ProviderCallContext", ",", "ids", "[", "]", "instance", ".", "Id", ")", "(", "[", "]", "instances", ".", "Instance", ",", "error", ")", "{", "if", "len", "(", "ids", ")", "==", "0", "{", "// This would be treated as \"return all instances\" below, so", "// treat it as a special case.", "// The interface requires us to return this particular error", "// if no instances were found.", "return", "nil", ",", "environs", ".", "ErrNoInstances", "\n", "}", "\n", "acquired", ",", "err", ":=", "env", ".", "acquiredInstances", "(", "ctx", ",", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "acquired", ")", "==", "0", "{", "return", "nil", ",", "environs", ".", "ErrNoInstances", "\n", "}", "\n\n", "idMap", ":=", "make", "(", "map", "[", "instance", ".", "Id", "]", "instances", ".", "Instance", ")", "\n", "for", "_", ",", "instance", ":=", "range", "acquired", "{", "idMap", "[", "instance", ".", "Id", "(", ")", "]", "=", "instance", "\n", "}", "\n\n", "missing", ":=", "false", "\n", "result", ":=", "make", "(", "[", "]", "instances", ".", "Instance", ",", "len", "(", "ids", ")", ")", "\n", "for", "index", ",", "id", ":=", "range", "ids", "{", "val", ",", "ok", ":=", "idMap", "[", "id", "]", "\n", "if", "!", "ok", "{", "missing", "=", "true", "\n", "continue", "\n", "}", "\n", "result", "[", "index", "]", "=", "val", "\n", "}", "\n\n", "if", "missing", "{", "return", "result", ",", "environs", ".", "ErrPartialInstances", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Instances", "returns", "the", "instances", ".", "Instance", "objects", "corresponding", "to", "the", "given", "slice", "of", "instance", ".", "Id", ".", "The", "error", "is", "ErrNoInstances", "if", "no", "instances", "were", "found", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "instances1", "(", "ctx", "context", ".", "ProviderCallContext", ",", "filter", "url", ".", "Values", ")", "(", "[", "]", "instances", ".", "Instance", ",", "error", ")", "{", "nodeListing", ":=", "env", ".", "getMAASClient", "(", ")", ".", "GetSubObject", "(", "\"", "\"", ")", "\n", "listNodeObjects", ",", "err", ":=", "nodeListing", ".", "CallGet", "(", "\"", "\"", ",", "filter", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "listNodes", ",", "err", ":=", "listNodeObjects", ".", "GetArray", "(", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "instances", ":=", "make", "(", "[", "]", "instances", ".", "Instance", ",", "len", "(", "listNodes", ")", ")", "\n", "for", "index", ",", "nodeObj", ":=", "range", "listNodes", "{", "node", ",", "err", ":=", "nodeObj", ".", "GetMAASObject", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "instances", "[", "index", "]", "=", "&", "maas1Instance", "{", "maasObject", ":", "&", "node", ",", "environ", ":", "env", ",", "statusGetter", ":", "env", ".", "deploymentStatusOne", ",", "}", "\n", "}", "\n", "return", "instances", ",", "nil", "\n", "}" ]

[ "instances", "calls", "the", "MAAS", "API", "to", "list", "nodes", "matching", "the", "given", "filter", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "subnetsFromNode", "(", "ctx", "context", ".", "ProviderCallContext", ",", "nodeId", "string", ")", "(", "[", "]", "gomaasapi", ".", "JSONObject", ",", "error", ")", "{", "client", ":=", "env", ".", "getMAASClient", "(", ")", ".", "GetSubObject", "(", "\"", "\"", ")", ".", "GetSubObject", "(", "nodeId", ")", "\n", "json", ",", "err", ":=", "client", ".", "CallGet", "(", "\"", "\"", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "if", "maasErr", ",", "ok", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "gomaasapi", ".", "ServerError", ")", ";", "ok", "&&", "maasErr", ".", "StatusCode", "==", "http", ".", "StatusNotFound", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "nodeId", ")", "\n", "}", "\n", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "nodeMap", ",", "err", ":=", "json", ".", "GetMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "interfacesArray", ",", "err", ":=", "nodeMap", "[", "\"", "\"", "]", ".", "GetArray", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "subnets", "[", "]", "gomaasapi", ".", "JSONObject", "\n", "for", "_", ",", "iface", ":=", "range", "interfacesArray", "{", "ifaceMap", ",", "err", ":=", "iface", ".", "GetMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "linksArray", ",", "err", ":=", "ifaceMap", "[", "\"", "\"", "]", ".", "GetArray", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "link", ":=", "range", "linksArray", "{", "linkMap", ",", "err", ":=", "link", ".", "GetMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "subnet", ",", "ok", ":=", "linkMap", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "subnets", "=", "append", "(", "subnets", ",", "subnet", ")", "\n", "}", "\n", "}", "\n", "return", "subnets", ",", "nil", "\n", "}" ]

[ "subnetsFromNode", "fetches", "all", "the", "subnets", "for", "a", "specific", "node", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "subnetFromJson", "(", "subnet", "gomaasapi", ".", "JSONObject", ",", "spaceId", "network", ".", "Id", ")", "(", "network", ".", "SubnetInfo", ",", "error", ")", "{", "var", "subnetInfo", "network", ".", "SubnetInfo", "\n", "fields", ",", "err", ":=", "subnet", ".", "GetMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "subnetInfo", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "subnetIdFloat", ",", "err", ":=", "fields", "[", "\"", "\"", "]", ".", "GetFloat64", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "subnetInfo", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "subnetId", ":=", "strconv", ".", "Itoa", "(", "int", "(", "subnetIdFloat", ")", ")", "\n", "cidr", ",", "err", ":=", "fields", "[", "\"", "\"", "]", ".", "GetString", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "subnetInfo", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "vid", ":=", "0", "\n", "vidField", ",", "ok", ":=", "fields", "[", "\"", "\"", "]", "\n", "if", "ok", "&&", "!", "vidField", ".", "IsNil", "(", ")", "{", "// vid is optional, so assume it's 0 when missing or nil.", "vidFloat", ",", "err", ":=", "vidField", ".", "GetFloat64", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "subnetInfo", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "vid", "=", "int", "(", "vidFloat", ")", "\n", "}", "\n\n", "subnetInfo", "=", "network", ".", "SubnetInfo", "{", "ProviderId", ":", "network", ".", "Id", "(", "subnetId", ")", ",", "VLANTag", ":", "vid", ",", "CIDR", ":", "cidr", ",", "SpaceProviderId", ":", "spaceId", ",", "}", "\n", "return", "subnetInfo", ",", "nil", "\n", "}" ]

[ "subnetFromJson", "populates", "a", "network", ".", "SubnetInfo", "from", "a", "gomaasapi", ".", "JSONObject", "representing", "a", "single", "subnet", ".", "This", "can", "come", "from", "either", "the", "subnets", "api", "endpoint", "or", "the", "node", "endpoint", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "fetchAllSubnets", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "gomaasapi", ".", "JSONObject", ",", "error", ")", "{", "client", ":=", "env", ".", "getMAASClient", "(", ")", ".", "GetSubObject", "(", "\"", "\"", ")", "\n\n", "json", ",", "err", ":=", "client", ".", "CallGet", "(", "\"", "\"", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "json", ".", "GetArray", "(", ")", "\n", "}" ]

[ "fetchAllSubnets", "calls", "the", "MAAS", "subnets", "API", "to", "get", "all", "subnets", "and", "returns", "the", "JSON", "response", "or", "an", "error", ".", "If", "capNetworkDeploymentUbuntu", "is", "not", "available", "an", "error", "satisfying", "errors", ".", "IsNotSupported", "will", "be", "returned", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "subnetToSpaceIds", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "map", "[", "string", "]", "network", ".", "Id", ",", "error", ")", "{", "subnetsMap", ":=", "make", "(", "map", "[", "string", "]", "network", ".", "Id", ")", "\n", "spaces", ",", "err", ":=", "env", ".", "Spaces", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "subnetsMap", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "space", ":=", "range", "spaces", "{", "for", "_", ",", "subnet", ":=", "range", "space", ".", "Subnets", "{", "subnetsMap", "[", "subnet", ".", "CIDR", "]", "=", "space", ".", "ProviderId", "\n", "}", "\n", "}", "\n", "return", "subnetsMap", ",", "nil", "\n", "}" ]

[ "subnetToSpaceIds", "fetches", "the", "spaces", "from", "MAAS", "and", "builds", "a", "map", "of", "subnets", "to", "space", "ids", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "Spaces", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "network", ".", "SpaceInfo", ",", "error", ")", "{", "if", "!", "env", ".", "usingMAAS2", "(", ")", "{", "return", "env", ".", "spaces1", "(", "ctx", ")", "\n", "}", "\n", "return", "env", ".", "spaces2", "(", "ctx", ")", "\n", "}" ]

[ "Spaces", "returns", "all", "the", "spaces", "that", "have", "subnets", "known", "to", "the", "provider", ".", "Space", "name", "is", "not", "filled", "in", "as", "the", "provider", "doesn", "t", "know", "the", "juju", "name", "for", "the", "space", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "Subnets", "(", "ctx", "context", ".", "ProviderCallContext", ",", "instId", "instance", ".", "Id", ",", "subnetIds", "[", "]", "network", ".", "Id", ")", "(", "[", "]", "network", ".", "SubnetInfo", ",", "error", ")", "{", "if", "env", ".", "usingMAAS2", "(", ")", "{", "return", "env", ".", "subnets2", "(", "ctx", ",", "instId", ",", "subnetIds", ")", "\n", "}", "\n", "return", "env", ".", "subnets1", "(", "ctx", ",", "instId", ",", "subnetIds", ")", "\n", "}" ]

[ "Subnets", "returns", "basic", "information", "about", "the", "specified", "subnets", "known", "by", "the", "provider", "for", "the", "specified", "instance", ".", "subnetIds", "must", "not", "be", "empty", ".", "Implements", "NetworkingEnviron", ".", "Subnets", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "AllInstances", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "instances", ".", "Instance", ",", "error", ")", "{", "return", "env", ".", "acquiredInstances", "(", "ctx", ",", "nil", ")", "\n", "}" ]

[ "AllInstances", "returns", "all", "the", "instances", ".", "Instance", "in", "this", "provider", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "Storage", "(", ")", "storage", ".", "Storage", "{", "env", ".", "ecfgMutex", ".", "Lock", "(", ")", "\n", "defer", "env", ".", "ecfgMutex", ".", "Unlock", "(", ")", "\n", "return", "env", ".", "storageUnlocked", "\n", "}" ]

[ "Storage", "is", "defined", "by", "the", "Environ", "interface", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "AdoptResources", "(", "ctx", "context", ".", "ProviderCallContext", ",", "controllerUUID", "string", ",", "fromVersion", "version", ".", "Number", ")", "error", "{", "if", "!", "env", ".", "usingMAAS2", "(", ")", "{", "// We don't track instance -> controller for MAAS1.", "return", "nil", "\n", "}", "\n\n", "instances", ",", "err", ":=", "env", ".", "AllInstances", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "failed", "[", "]", "instance", ".", "Id", "\n", "for", "_", ",", "inst", ":=", "range", "instances", "{", "maas2Instance", ",", "ok", ":=", "inst", ".", "(", "*", "maas2Instance", ")", "\n", "if", "!", "ok", "{", "// This should never happen.", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "inst", ".", "Id", "(", ")", ")", "\n", "}", "\n", "// From the MAAS docs: \"[SetOwnerData] will not remove any", "// previous keys unless explicitly passed with an empty", "// string.\" So not passing all of the keys here is fine.", "// https://maas.ubuntu.com/docs2.0/api.html#machine", "err", ":=", "maas2Instance", ".", "machine", ".", "SetOwnerData", "(", "map", "[", "string", "]", "string", "{", "tags", ".", "JujuController", ":", "controllerUUID", "}", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "inst", ".", "Id", "(", ")", ",", "err", ")", "\n", "failed", "=", "append", "(", "failed", ",", "inst", ".", "Id", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "failed", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "failed", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AdoptResources", "updates", "all", "the", "instances", "to", "indicate", "they", "are", "now", "associated", "with", "the", "specified", "controller", "." ]

[ "func", "(", "*", "maasEnviron", ")", "AreSpacesRoutable", "(", "ctx", "context", ".", "ProviderCallContext", ",", "space1", ",", "space2", "*", "environs", ".", "ProviderSpaceInfo", ")", "(", "bool", ",", "error", ")", "{", "return", "false", ",", "nil", "\n", "}" ]

[ "AreSpacesRoutable", "implements", "environs", ".", "NetworkingEnviron", "." ]

[ "func", "(", "env", "*", "maasEnviron", ")", "Domains", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "string", ",", "error", ")", "{", "maasDomains", ",", "err", ":=", "env", ".", "maasController", ".", "Domains", "(", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "result", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "domain", ":=", "range", "maasDomains", "{", "result", "=", "append", "(", "result", ",", "domain", ".", "Name", "(", ")", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Get", "the", "domains", "managed", "by", "MAAS", ".", "Currently", "we", "only", "need", "the", "name", "of", "the", "domain", ".", "If", "more", "information", "is", "needed", "This", "function", "can", "be", "updated", "to", "parse", "and", "return", "a", "structure", ".", "Client", "code", "would", "need", "to", "be", "updated", "." ]

[ "func", "RegisterUserImageDataSourceFunc", "(", "id", "string", ",", "f", "ImageDataSourceFunc", ")", "{", "datasourceFuncsMu", ".", "Lock", "(", ")", "\n", "defer", "datasourceFuncsMu", ".", "Unlock", "(", ")", "\n", "for", "i", ":=", "range", "datasourceFuncs", "{", "if", "datasourceFuncs", "[", "i", "]", ".", "id", "==", "id", "{", "datasourceFuncs", "[", "i", "]", ".", "f", "=", "f", "\n", "return", "\n", "}", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "id", ")", "\n", "datasourceFuncs", "=", "append", "(", "[", "]", "datasourceFuncId", "{", "{", "id", ",", "f", "}", "}", ",", "datasourceFuncs", "...", ")", "\n", "}" ]

[ "RegisterUserImageDataSourceFunc", "registers", "an", "ImageDataSourceFunc", "with", "the", "specified", "id", "at", "the", "start", "of", "the", "search", "path", "overwriting", "any", "function", "previously", "registered", "with", "the", "same", "id", "." ]

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

[ "UnregisterImageDataSourceFunc", "unregisters", "an", "ImageDataSourceFunc", "with", "the", "specified", "id", "." ]

[ "func", "ImageMetadataSources", "(", "env", "BootstrapEnviron", ")", "(", "[", "]", "simplestreams", ".", "DataSource", ",", "error", ")", "{", "config", ":=", "env", ".", "Config", "(", ")", "\n\n", "// Add configured and environment-specific datasources.", "var", "sources", "[", "]", "simplestreams", ".", "DataSource", "\n", "if", "userURL", ",", "ok", ":=", "config", ".", "ImageMetadataURL", "(", ")", ";", "ok", "{", "verify", ":=", "utils", ".", "VerifySSLHostnames", "\n", "if", "!", "config", ".", "SSLHostnameVerification", "(", ")", "{", "verify", "=", "utils", ".", "NoVerifySSLHostnames", "\n", "}", "\n", "publicKey", ",", "_", ":=", "simplestreams", ".", "UserPublicSigningKey", "(", ")", "\n", "sources", "=", "append", "(", "sources", ",", "simplestreams", ".", "NewURLSignedDataSource", "(", "\"", "\"", ",", "userURL", ",", "publicKey", ",", "verify", ",", "simplestreams", ".", "SPECIFIC_CLOUD_DATA", ",", "false", ")", ")", "\n", "}", "\n\n", "envDataSources", ",", "err", ":=", "environmentDataSources", "(", "env", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "sources", "=", "append", "(", "sources", ",", "envDataSources", "...", ")", "\n\n", "// Add the official image metadata datasources.", "officialDataSources", ",", "err", ":=", "imagemetadata", ".", "OfficialDataSources", "(", "config", ".", "ImageStream", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "source", ":=", "range", "officialDataSources", "{", "sources", "=", "append", "(", "sources", ",", "source", ")", "\n", "}", "\n", "for", "_", ",", "ds", ":=", "range", "sources", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "ds", ".", "Description", "(", ")", ")", "\n", "}", "\n", "return", "sources", ",", "nil", "\n", "}" ]

[ "ImageMetadataSources", "returns", "the", "sources", "to", "use", "when", "looking", "for", "simplestreams", "image", "id", "metadata", "for", "the", "given", "stream", "." ]

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

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

[ "func", "(", "r", "*", "globalProviderRegistry", ")", "UnregisterProvider", "(", "providerType", "string", ")", "{", "delete", "(", "r", ".", "providers", ",", "providerType", ")", "\n", "for", "a", ",", "p", ":=", "range", "r", ".", "aliases", "{", "if", "p", "==", "providerType", "{", "delete", "(", "r", ".", "aliases", ",", "a", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "UnregisterProvider", "removes", "the", "named", "provider", "from", "the", "list", "of", "available", "providers", "." ]

[ "func", "RegisterProvider", "(", "name", "string", ",", "p", "CloudEnvironProvider", ",", "alias", "...", "string", ")", "(", "unregister", "func", "(", ")", ")", "{", "if", "err", ":=", "GlobalProviderRegistry", "(", ")", ".", "RegisterProvider", "(", "p", ",", "name", ",", "alias", "...", ")", ";", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "return", "func", "(", ")", "{", "GlobalProviderRegistry", "(", ")", ".", "UnregisterProvider", "(", "name", ")", "\n", "}", "\n", "}" ]

[ "RegisterProvider", "registers", "a", "new", "environment", "provider", ".", "Name", "gives", "the", "name", "of", "the", "provider", "and", "p", "the", "interface", "to", "that", "provider", ".", "RegisterProvider", "will", "panic", "if", "the", "provider", "name", "or", "any", "of", "the", "aliases", "are", "registered", "more", "than", "once", ".", "The", "return", "function", "can", "be", "used", "to", "unregister", "the", "provider", "and", "is", "used", "by", "tests", "." ]

[ "func", "Open", "(", "cfg", "RawConfig", ")", "(", "*", "Client", ",", "error", ")", "{", "client", ",", "err", ":=", "OpenForSender", "(", "cfg", ",", "&", "senderOpener", "{", "}", ")", "\n", "return", "client", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "Open", "connects", "to", "a", "remote", "syslog", "host", "and", "wraps", "that", "connection", "in", "a", "new", "client", "." ]

[ "func", "OpenForSender", "(", "cfg", "RawConfig", ",", "opener", "SenderOpener", ")", "(", "*", "Client", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "sender", ",", "err", ":=", "open", "(", "cfg", ",", "opener", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "client", ":=", "&", "Client", "{", "Sender", ":", "sender", ",", "}", "\n", "return", "client", ",", "nil", "\n", "}" ]

[ "OpenForSender", "connects", "to", "a", "remote", "syslog", "host", "and", "wraps", "that", "connection", "in", "a", "new", "client", "." ]

[ "func", "(", "client", "Client", ")", "Close", "(", ")", "error", "{", "err", ":=", "client", ".", "Sender", ".", "Close", "(", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "Close", "closes", "the", "client", "s", "connection", "." ]

[ "func", "(", "client", "Client", ")", "Send", "(", "records", "[", "]", "logfwd", ".", "Record", ")", "error", "{", "for", "_", ",", "rec", ":=", "range", "records", "{", "msg", ",", "err", ":=", "messageFromRecord", "(", "rec", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "client", ".", "Sender", ".", "Send", "(", "msg", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Send", "sends", "the", "record", "to", "the", "remote", "syslog", "host", "." ]

[ "func", "CollectionFromName", "(", "db", "*", "mgo", ".", "Database", ",", "coll", "string", ")", "(", "Collection", ",", "func", "(", ")", ")", "{", "session", ":=", "db", ".", "Session", ".", "Copy", "(", ")", "\n", "newColl", ":=", "db", ".", "C", "(", "coll", ")", ".", "With", "(", "session", ")", "\n", "return", "WrapCollection", "(", "newColl", ")", ",", "session", ".", "Close", "\n", "}" ]

[ "CollectionFromName", "returns", "a", "named", "collection", "on", "the", "specified", "database", "initialised", "with", "a", "new", "session", ".", "Also", "returned", "is", "a", "close", "function", "which", "must", "be", "called", "when", "the", "collection", "is", "no", "longer", "required", "." ]

[ "func", "(", "cw", "collectionWrapper", ")", "Find", "(", "query", "interface", "{", "}", ")", "Query", "{", "return", "queryWrapper", "{", "cw", ".", "Collection", ".", "Find", "(", "query", ")", "}", "\n", "}" ]

[ "Find", "is", "part", "of", "the", "Collection", "interface", "." ]

[ "func", "(", "cw", "collectionWrapper", ")", "Pipe", "(", "pipeline", "interface", "{", "}", ")", "*", "mgo", ".", "Pipe", "{", "return", "cw", ".", "Collection", ".", "Pipe", "(", "pipeline", ")", "\n", "}" ]

[ "Pipe", "is", "part", "of", "the", "Collection", "interface" ]

[ "func", "(", "cw", "collectionWrapper", ")", "FindId", "(", "id", "interface", "{", "}", ")", "Query", "{", "return", "queryWrapper", "{", "cw", ".", "Collection", ".", "FindId", "(", "id", ")", "}", "\n", "}" ]

[ "FindId", "is", "part", "of", "the", "Collection", "interface", "." ]

[ "func", "NewListCredentialsCommand", "(", ")", "cmd", ".", "Command", "{", "return", "&", "listCredentialsCommand", "{", "store", ":", "jujuclient", ".", "NewFileCredentialStore", "(", ")", ",", "cloudByNameFunc", ":", "jujucloud", ".", "CloudByName", ",", "}", "\n", "}" ]

[ "NewListCredentialsCommand", "returns", "a", "command", "to", "list", "cloud", "credentials", "." ]

[ "func", "formatCredentialsTabular", "(", "writer", "io", ".", "Writer", ",", "value", "interface", "{", "}", ")", "error", "{", "credentials", ",", "ok", ":=", "value", ".", "(", "credentialsMap", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "credentials", ",", "value", ")", "\n", "}", "\n\n", "if", "len", "(", "credentials", ".", "Credentials", ")", "==", "0", "{", "fmt", ".", "Fprintln", "(", "writer", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// For tabular we'll sort alphabetically by cloud, and then by credential name.", "var", "cloudNames", "[", "]", "string", "\n", "for", "name", ":=", "range", "credentials", ".", "Credentials", "{", "cloudNames", "=", "append", "(", "cloudNames", ",", "name", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "cloudNames", ")", "\n\n", "tw", ":=", "output", ".", "TabWriter", "(", "writer", ")", "\n", "w", ":=", "output", ".", "Wrapper", "{", "tw", "}", "\n", "w", ".", "Println", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "for", "_", ",", "cloudName", ":=", "range", "cloudNames", "{", "var", "haveDefault", "bool", "\n", "var", "credentialNames", "[", "]", "string", "\n", "credentials", ":=", "credentials", ".", "Credentials", "[", "cloudName", "]", "\n", "for", "credentialName", ":=", "range", "credentials", ".", "Credentials", "{", "if", "credentialName", "==", "credentials", ".", "DefaultCredential", "{", "credentialNames", "=", "append", "(", "[", "]", "string", "{", "credentialName", "+", "\"", "\"", "}", ",", "credentialNames", "...", ")", "\n", "haveDefault", "=", "true", "\n", "}", "else", "{", "credentialNames", "=", "append", "(", "credentialNames", ",", "credentialName", ")", "\n", "}", "\n", "}", "\n", "if", "haveDefault", "{", "sort", ".", "Strings", "(", "credentialNames", "[", "1", ":", "]", ")", "\n", "}", "else", "{", "sort", ".", "Strings", "(", "credentialNames", ")", "\n", "}", "\n", "w", ".", "Println", "(", "cloudName", ",", "strings", ".", "Join", "(", "credentialNames", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "tw", ".", "Flush", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "formatCredentialsTabular", "writes", "a", "tabular", "summary", "of", "cloud", "information", "." ]

[ "func", "NewFacade", "(", "st", "*", "state", ".", "State", ",", "resources", "facade", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ",", ")", "(", "*", "InstancePollerAPI", ",", "error", ")", "{", "m", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "NewInstancePollerAPI", "(", "st", ",", "m", ",", "resources", ",", "authorizer", ",", "clock", ".", "WallClock", ")", "\n", "}" ]

[ "NewFacade", "wraps", "NewInstancePollerAPI", "for", "facade", "registration", "." ]

[ "func", "NewInstancePollerAPI", "(", "st", "*", "state", ".", "State", ",", "m", "*", "state", ".", "Model", ",", "resources", "facade", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ",", "clock", "clock", ".", "Clock", ",", ")", "(", "*", "InstancePollerAPI", ",", "error", ")", "{", "if", "!", "authorizer", ".", "AuthController", "(", ")", "{", "// InstancePoller must run as a controller.", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "accessMachine", ":=", "common", ".", "AuthFuncForTagKind", "(", "names", ".", "MachineTagKind", ")", "\n", "sti", ":=", "getState", "(", "st", ",", "m", ")", "\n\n", "// Life() is supported for machines.", "lifeGetter", ":=", "common", ".", "NewLifeGetter", "(", "sti", ",", "accessMachine", ",", ")", "\n", "// ModelConfig() and WatchForModelConfigChanges() are allowed", "// with unrestricted access.", "modelWatcher", ":=", "common", ".", "NewModelWatcher", "(", "sti", ",", "resources", ",", "authorizer", ",", ")", "\n", "// WatchModelMachines() is allowed with unrestricted access.", "machinesWatcher", ":=", "common", ".", "NewModelMachinesWatcher", "(", "sti", ",", "resources", ",", "authorizer", ",", ")", "\n", "// InstanceId() is supported for machines.", "instanceIdGetter", ":=", "common", ".", "NewInstanceIdGetter", "(", "sti", ",", "accessMachine", ",", ")", "\n", "// Status() is supported for machines.", "statusGetter", ":=", "common", ".", "NewStatusGetter", "(", "sti", ",", "accessMachine", ",", ")", "\n\n", "return", "&", "InstancePollerAPI", "{", "LifeGetter", ":", "lifeGetter", ",", "ModelWatcher", ":", "modelWatcher", ",", "ModelMachinesWatcher", ":", "machinesWatcher", ",", "InstanceIdGetter", ":", "instanceIdGetter", ",", "StatusGetter", ":", "statusGetter", ",", "st", ":", "sti", ",", "resources", ":", "resources", ",", "authorizer", ":", "authorizer", ",", "accessMachine", ":", "accessMachine", ",", "clock", ":", "clock", ",", "}", ",", "nil", "\n", "}" ]

[ "NewInstancePollerAPI", "creates", "a", "new", "server", "-", "side", "InstancePoller", "API", "facade", "." ]

[ "func", "(", "a", "*", "InstancePollerAPI", ")", "ProviderAddresses", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "MachineAddressesResults", ",", "error", ")", "{", "result", ":=", "params", ".", "MachineAddressesResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "MachineAddressesResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "canAccess", ",", "err", ":=", "a", ".", "accessMachine", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Entities", "{", "machine", ",", "err", ":=", "a", ".", "getOneMachine", "(", "arg", ".", "Tag", ",", "canAccess", ")", "\n", "if", "err", "==", "nil", "{", "addrs", ":=", "machine", ".", "ProviderAddresses", "(", ")", "\n", "result", ".", "Results", "[", "i", "]", ".", "Addresses", "=", "params", ".", "FromNetworkAddresses", "(", "addrs", "...", ")", "\n", "}", "\n", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "ProviderAddresses", "returns", "the", "list", "of", "all", "known", "provider", "addresses", "for", "each", "given", "entity", ".", "Only", "machine", "tags", "are", "accepted", "." ]

[ "func", "(", "a", "*", "InstancePollerAPI", ")", "SetProviderAddresses", "(", "args", "params", ".", "SetMachinesAddresses", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "result", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "MachineAddresses", ")", ")", ",", "}", "\n", "canAccess", ",", "err", ":=", "a", ".", "accessMachine", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "MachineAddresses", "{", "machine", ",", "err", ":=", "a", ".", "getOneMachine", "(", "arg", ".", "Tag", ",", "canAccess", ")", "\n", "if", "err", "==", "nil", "{", "addrsToSet", ":=", "params", ".", "NetworkAddresses", "(", "arg", ".", "Addresses", "...", ")", "\n", "err", "=", "machine", ".", "SetProviderAddresses", "(", "addrsToSet", "...", ")", "\n", "}", "\n", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "SetProviderAddresses", "updates", "the", "list", "of", "known", "provider", "addresses", "for", "each", "given", "entity", ".", "Only", "machine", "tags", "are", "accepted", "." ]

[ "func", "(", "a", "*", "InstancePollerAPI", ")", "SetInstanceStatus", "(", "args", "params", ".", "SetStatus", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "result", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "canAccess", ",", "err", ":=", "a", ".", "accessMachine", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Entities", "{", "machine", ",", "err", ":=", "a", ".", "getOneMachine", "(", "arg", ".", "Tag", ",", "canAccess", ")", "\n", "if", "err", "==", "nil", "{", "now", ":=", "a", ".", "clock", ".", "Now", "(", ")", "\n", "s", ":=", "status", ".", "StatusInfo", "{", "Status", ":", "status", ".", "Status", "(", "arg", ".", "Status", ")", ",", "Message", ":", "arg", ".", "Info", ",", "Data", ":", "arg", ".", "Data", ",", "Since", ":", "&", "now", ",", "}", "\n", "err", "=", "machine", ".", "SetInstanceStatus", "(", "s", ")", "\n", "if", "status", ".", "Status", "(", "arg", ".", "Status", ")", "==", "status", ".", "ProvisioningError", "{", "s", ".", "Status", "=", "status", ".", "Error", "\n", "if", "err", "==", "nil", "{", "err", "=", "machine", ".", "SetStatus", "(", "s", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "result", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "SetInstanceStatus", "updates", "the", "instance", "status", "for", "each", "given", "entity", ".", "Only", "machine", "tags", "are", "accepted", "." ]

[ "func", "AdminFacadeDetails", "(", ")", "[", "]", "facade", ".", "Details", "{", "var", "fs", "[", "]", "facade", ".", "Details", "\n", "for", "v", ",", "f", ":=", "range", "adminAPIFactories", "{", "api", ":=", "f", "(", "nil", ",", "nil", ",", "nil", ")", "\n", "t", ":=", "reflect", ".", "TypeOf", "(", "api", ")", "\n", "fs", "=", "append", "(", "fs", ",", "facade", ".", "Details", "{", "Name", ":", "\"", "\"", ",", "Version", ":", "v", ",", "Type", ":", "t", ",", "}", ")", "\n", "}", "\n", "return", "fs", "\n", "}" ]

[ "AdminFacadeDetails", "returns", "information", "on", "the", "Admin", "facade", "provided", "at", "login", "time", ".", "The", "Facade", "field", "of", "the", "returned", "slice", "elements", "will", "be", "nil", "." ]

[ "func", "isKnownStorageAccountType", "(", "t", "string", ")", "bool", "{", "for", "_", ",", "knownStorageAccountType", ":=", "range", "knownStorageAccountTypes", "{", "if", "t", "==", "knownStorageAccountType", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isKnownStorageAccountType", "reports", "whether", "or", "not", "the", "given", "string", "identifies", "a", "known", "storage", "account", "type", "." ]

[ "func", "canonicalLocation", "(", "s", "string", ")", "string", "{", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "return", "strings", ".", "ToLower", "(", "s", ")", "\n", "}" ]

[ "canonicalLocation", "returns", "the", "canonicalized", "location", "string", ".", "This", "involves", "stripping", "whitespace", "and", "lowercasing", ".", "The", "ARM", "APIs", "do", "not", "support", "embedded", "whitespace", "whereas", "the", "old", "Service", "Management", "APIs", "used", "to", ";", "we", "allow", "the", "user", "to", "provide", "either", "and", "canonicalize", "them", "to", "one", "form", "that", "ARM", "allows", "." ]

[ "func", "NewIngressRule", "(", "protocol", "string", ",", "from", ",", "to", "int", ",", "sourceCIDRs", "...", "string", ")", "(", "IngressRule", ",", "error", ")", "{", "rule", ":=", "IngressRule", "{", "PortRange", ":", "network", ".", "PortRange", "{", "Protocol", ":", "protocol", ",", "FromPort", ":", "from", ",", "ToPort", ":", "to", ",", "}", ",", "}", "\n", "for", "_", ",", "cidr", ":=", "range", "sourceCIDRs", "{", "if", "_", ",", "_", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "cidr", ")", ";", "err", "!=", "nil", "{", "return", "IngressRule", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "sourceCIDRs", ")", ">", "0", "{", "rule", ".", "SourceCIDRs", "=", "sourceCIDRs", "\n", "}", "\n", "return", "rule", ",", "nil", "\n", "}" ]

[ "NewIngressRule", "returns", "an", "IngressRule", "for", "the", "specified", "port", "range", ".", "If", "no", "explicit", "source", "ranges", "are", "specified", "there", "is", "no", "restriction", "from", "where", "incoming", "traffic", "originates", "." ]

[ "func", "MustNewIngressRule", "(", "protocol", "string", ",", "from", ",", "to", "int", ",", "sourceCIDRs", "...", "string", ")", "IngressRule", "{", "rule", ",", "err", ":=", "NewIngressRule", "(", "protocol", ",", "from", ",", "to", ",", "sourceCIDRs", "...", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "rule", "\n", "}" ]

[ "MustNewIngressRule", "returns", "an", "IngressRule", "for", "the", "specified", "port", "range", ".", "If", "no", "explicit", "source", "ranges", "are", "specified", "there", "is", "no", "restriction", "from", "where", "incoming", "traffic", "originates", ".", "The", "method", "will", "panic", "if", "there", "is", "an", "error", "." ]

[ "func", "NewOpenIngressRule", "(", "protocol", "string", ",", "from", ",", "to", "int", ")", "IngressRule", "{", "rule", ",", "_", ":=", "NewIngressRule", "(", "protocol", ",", "from", ",", "to", ")", "\n", "return", "rule", "\n", "}" ]

[ "NewOpenIngressRule", "returns", "an", "IngressRule", "for", "the", "specified", "port", "range", ".", "There", "is", "no", "restriction", "from", "where", "incoming", "traffic", "originates", "." ]

[ "func", "(", "r", "IngressRule", ")", "String", "(", ")", "string", "{", "source", ":=", "\"", "\"", "\n", "from", ":=", "strings", ".", "Join", "(", "r", ".", "SourceCIDRs", ",", "\"", "\"", ")", "\n", "if", "from", "!=", "\"", "\"", "&&", "from", "!=", "\"", "\"", "{", "source", "=", "\"", "\"", "+", "from", "\n", "}", "\n", "if", "r", ".", "FromPort", "==", "r", ".", "ToPort", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "FromPort", ",", "strings", ".", "ToLower", "(", "r", ".", "Protocol", ")", ",", "source", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "FromPort", ",", "r", ".", "ToPort", ",", "strings", ".", "ToLower", "(", "r", ".", "Protocol", ")", ",", "source", ")", "\n", "}" ]

[ "String", "is", "the", "string", "representation", "of", "IngressRule", "." ]

[ "func", "removeContainerRefOps", "(", "mb", "modelBackend", ",", "machineId", "string", ")", "[", "]", "txn", ".", "Op", "{", "removeRefOp", ":=", "txn", ".", "Op", "{", "C", ":", "containerRefsC", ",", "Id", ":", "mb", ".", "docID", "(", "machineId", ")", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Remove", ":", "true", ",", "}", "\n", "// If the machine is a container, figure out its parent host.", "parentId", ":=", "ParentId", "(", "machineId", ")", "\n", "if", "parentId", "==", "\"", "\"", "{", "return", "[", "]", "txn", ".", "Op", "{", "removeRefOp", "}", "\n", "}", "\n", "removeParentRefOp", ":=", "txn", ".", "Op", "{", "C", ":", "containerRefsC", ",", "Id", ":", "mb", ".", "docID", "(", "parentId", ")", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "machineId", "}", "}", "}", "}", ",", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "removeRefOp", ",", "removeParentRefOp", "}", "\n", "}" ]

[ "removeContainerRefOps", "returns", "the", "txn", ".", "Op", "s", "necessary", "to", "remove", "a", "machine", "container", "record", ".", "These", "include", "removing", "the", "record", "itself", "and", "updating", "the", "host", "machine", "s", "children", "property", "." ]

[ "func", "ParentId", "(", "machineId", "string", ")", "string", "{", "idParts", ":=", "strings", ".", "Split", "(", "machineId", ",", "\"", "\"", ")", "\n", "if", "len", "(", "idParts", ")", "<", "3", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "idParts", "[", ":", "len", "(", "idParts", ")", "-", "2", "]", ",", "\"", "\"", ")", "\n", "}" ]

[ "ParentId", "returns", "the", "id", "of", "the", "host", "machine", "if", "machineId", "a", "container", "id", "or", "if", "machineId", "is", "not", "for", "a", "container", "." ]

[ "func", "ContainerTypeFromId", "(", "machineId", "string", ")", "instance", ".", "ContainerType", "{", "idParts", ":=", "strings", ".", "Split", "(", "machineId", ",", "\"", "\"", ")", "\n", "if", "len", "(", "idParts", ")", "<", "3", "{", "return", "instance", ".", "ContainerType", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "instance", ".", "ContainerType", "(", "idParts", "[", "len", "(", "idParts", ")", "-", "2", "]", ")", "\n", "}" ]

[ "ContainerTypeFromId", "returns", "the", "container", "type", "if", "machineId", "is", "a", "container", "id", "or", "if", "machineId", "is", "not", "for", "a", "container", "." ]

[ "func", "NestingLevel", "(", "machineId", "string", ")", "int", "{", "idParts", ":=", "strings", ".", "Split", "(", "machineId", ",", "\"", "\"", ")", "\n", "return", "(", "len", "(", "idParts", ")", "-", "1", ")", "/", "2", "\n", "}" ]

[ "NestingLevel", "returns", "how", "many", "levels", "of", "nesting", "exist", "for", "a", "machine", "id", "." ]

[ "func", "createEndpointBindingsOp", "(", "st", "*", "State", ",", "key", "string", ",", "givenMap", "map", "[", "string", "]", "string", ",", "meta", "*", "charm", ".", "Meta", ")", "(", "txn", ".", "Op", ",", "error", ")", "{", "// No existing map to merge, just use the defaults.", "initialMap", ",", "_", ",", "err", ":=", "mergeBindings", "(", "givenMap", ",", "nil", ",", "meta", ")", "\n", "if", "err", "!=", "nil", "{", "return", "txn", ".", "Op", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Validate the bindings before inserting.", "if", "err", ":=", "validateEndpointBindingsForCharm", "(", "st", ",", "initialMap", ",", "meta", ")", ";", "err", "!=", "nil", "{", "return", "txn", ".", "Op", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "txn", ".", "Op", "{", "C", ":", "endpointBindingsC", ",", "Id", ":", "key", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "endpointBindingsDoc", "{", "Bindings", ":", "initialMap", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "createEndpointBindingsOp", "returns", "the", "op", "needed", "to", "create", "new", "endpoint", "bindings", "using", "the", "optional", "givenMap", "and", "the", "specified", "charm", "metadata", "to", "for", "determining", "defaults", "and", "to", "validate", "the", "effective", "bindings", "." ]

[ "func", "updateEndpointBindingsOp", "(", "st", "*", "State", ",", "key", "string", ",", "givenMap", "map", "[", "string", "]", "string", ",", "newMeta", "*", "charm", ".", "Meta", ")", "(", "txn", ".", "Op", ",", "error", ")", "{", "// Fetch existing bindings.", "existingMap", ",", "txnRevno", ",", "err", ":=", "readEndpointBindings", "(", "st", ",", "key", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "txn", ".", "Op", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Merge existing with given as needed.", "updatedMap", ",", "isModified", ",", "err", ":=", "mergeBindings", "(", "givenMap", ",", "existingMap", ",", "newMeta", ")", "\n", "if", "err", "!=", "nil", "{", "return", "txn", ".", "Op", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Validate the bindings before updating.", "if", "err", ":=", "validateEndpointBindingsForCharm", "(", "st", ",", "updatedMap", ",", "newMeta", ")", ";", "err", "!=", "nil", "{", "return", "txn", ".", "Op", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "!", "isModified", "{", "return", "txn", ".", "Op", "{", "}", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n\n", "// Prepare the update operations.", "escaped", ":=", "make", "(", "bson", ".", "M", ",", "len", "(", "updatedMap", ")", ")", "\n", "for", "endpoint", ",", "space", ":=", "range", "updatedMap", "{", "escaped", "[", "utils", ".", "EscapeKey", "(", "endpoint", ")", "]", "=", "space", "\n", "}", "\n\n", "updateOp", ":=", "txn", ".", "Op", "{", "C", ":", "endpointBindingsC", ",", "Id", ":", "key", ",", "Update", ":", "bson", ".", "M", "{", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "escaped", "}", "}", ",", "}", "\n", "if", "existingMap", "!=", "nil", "{", "// Only assert existing haven't changed when they actually exist.", "updateOp", ".", "Assert", "=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "txnRevno", "}", "}", "\n", "}", "\n", "return", "updateOp", ",", "nil", "\n", "}" ]

[ "updateEndpointBindingsOp", "returns", "an", "op", "that", "merges", "the", "existing", "bindings", "with", "givenMap", "using", "newMeta", "to", "validate", "the", "merged", "bindings", "and", "asserting", "the", "existing", "ones", "haven", "t", "changed", "in", "the", "since", "we", "fetched", "them", "." ]

[ "func", "removeEndpointBindingsOp", "(", "key", "string", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "endpointBindingsC", ",", "Id", ":", "key", ",", "Remove", ":", "true", ",", "}", "\n", "}" ]

[ "removeEndpointBindingsOp", "returns", "an", "op", "removing", "the", "bindings", "for", "the", "given", "key", "without", "asserting", "they", "exist", "in", "the", "first", "place", "." ]

[ "func", "(", "n", "*", "switchingNetworking", ")", "DefaultNetworks", "(", ")", "(", "[", "]", "nova", ".", "ServerNetworks", ",", "error", ")", "{", "if", "err", ":=", "n", ".", "initNetworking", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "n", ".", "networking", ".", "DefaultNetworks", "(", ")", "\n", "}" ]

[ "DefaultNetworks", "is", "part", "of", "the", "Networking", "interface", "." ]

[ "func", "(", "n", "*", "switchingNetworking", ")", "NetworkInterfaces", "(", "instId", "instance", ".", "Id", ")", "(", "[", "]", "network", ".", "InterfaceInfo", ",", "error", ")", "{", "if", "err", ":=", "n", ".", "initNetworking", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "n", ".", "networking", ".", "NetworkInterfaces", "(", "instId", ")", "\n", "}" ]

[ "NetworkInterfaces", "is", "part", "of", "the", "Networking", "interface" ]

[ "func", "getExternalNeutronNetworksByAZ", "(", "e", "*", "Environ", ",", "azName", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "neutron", ":=", "e", ".", "neutron", "(", ")", "\n", "// Find all external networks in availability zone", "networks", ",", "err", ":=", "neutron", ".", "ListNetworksV2", "(", "externalNetworkFilter", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "netIds", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "network", ":=", "range", "networks", "{", "for", "_", ",", "netAZ", ":=", "range", "network", ".", "AvailabilityZones", "{", "if", "azName", "==", "netAZ", "{", "netIds", "=", "append", "(", "netIds", ",", "network", ".", "Id", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "len", "(", "netIds", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "NewNotFound", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "netIds", ",", "nil", "\n", "}" ]

[ "getExternalNeutronNetworksByAZ", "returns", "all", "external", "networks", "within", "the", "given", "availability", "zone", ".", "If", "azName", "is", "empty", "return", "all", "external", "networks", "." ]

[ "func", "(", "n", "*", "NeutronNetworking", ")", "Subnets", "(", "instId", "instance", ".", "Id", ",", "subnetIds", "[", "]", "network", ".", "Id", ")", "(", "[", "]", "network", ".", "SubnetInfo", ",", "error", ")", "{", "netIds", ":=", "set", ".", "NewStrings", "(", ")", "\n", "neutron", ":=", "n", ".", "env", ".", "neutron", "(", ")", "\n", "internalNet", ":=", "n", ".", "env", ".", "ecfg", "(", ")", ".", "network", "(", ")", "\n", "netId", ",", "err", ":=", "resolveNeutronNetwork", "(", "neutron", ",", "internalNet", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "// Note: (jam 2018-05-23) We don't treat this as fatal because we used to never pay attention to it anyway", "if", "internalNet", "==", "\"", "\"", "{", "logger", ".", "Warningf", "(", "noNetConfigMsg", "(", "err", ")", ")", "\n", "}", "else", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "internalNet", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "netIds", ".", "Add", "(", "netId", ")", "\n", "// Note, there are cases where we will detect an external", "// network without it being explicitly configured by the user.", "// When we get to a point where we start detecting spaces for users", "// on Openstack, we'll probably need to include better logic here.", "externalNet", ":=", "n", ".", "env", ".", "ecfg", "(", ")", ".", "externalNetwork", "(", ")", "\n", "if", "externalNet", "!=", "\"", "\"", "{", "netId", ",", "err", ":=", "resolveNeutronNetwork", "(", "neutron", ",", "externalNet", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "externalNet", ",", "err", ")", "\n", "}", "else", "{", "netIds", ".", "Add", "(", "netId", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "netIds", ".", "Values", "(", ")", ",", "\"", "\"", ")", ")", "\n\n", "subIdSet", ":=", "set", ".", "NewStrings", "(", ")", "\n", "for", "_", ",", "subId", ":=", "range", "subnetIds", "{", "subIdSet", ".", "Add", "(", "string", "(", "subId", ")", ")", "\n", "}", "\n\n", "var", "results", "[", "]", "network", ".", "SubnetInfo", "\n", "if", "instId", "!=", "instance", ".", "UnknownId", "{", "// TODO(hml): 2017-03-20", "// Implement Subnets() for case where instId is specified", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ")", "\n", "}", "else", "{", "// TODO(jam): 2018-05-23 It is likely that ListSubnetsV2 could", "// take a Filter rather that doing the filtering client side.", "subnets", ",", "err", ":=", "neutron", ".", "ListSubnetsV2", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "subnetIds", ")", "==", "0", "{", "for", "_", ",", "subnet", ":=", "range", "subnets", "{", "// TODO (manadart 2018-07-17): If there was an error resolving", "// an internal network ID, then no subnets will be discovered.", "// The user will get an error attempting to add machines to", "// this model and will have to update model config with a", "// network name; but this does not re-discover the subnets.", "// If subnets/spaces become important, we will have to address", "// this somehow.", "if", "!", "netIds", ".", "Contains", "(", "subnet", ".", "NetworkId", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "subnet", ".", "Id", ",", "subnet", ".", "NetworkId", ")", "\n", "continue", "\n", "}", "\n", "subIdSet", ".", "Add", "(", "subnet", ".", "Id", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "subnet", ":=", "range", "subnets", "{", "if", "!", "subIdSet", ".", "Contains", "(", "subnet", ".", "Id", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "subnet", ".", "Id", ",", "subnetIds", ")", "\n", "continue", "\n", "}", "\n", "subIdSet", ".", "Remove", "(", "subnet", ".", "Id", ")", "\n", "if", "info", ",", "err", ":=", "makeSubnetInfo", "(", "neutron", ",", "subnet", ")", ";", "err", "==", "nil", "{", "// Error will already have been logged.", "results", "=", "append", "(", "results", ",", "info", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "!", "subIdSet", ".", "IsEmpty", "(", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "subIdSet", ".", "Values", "(", ")", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "Subnets", "returns", "basic", "information", "about", "the", "specified", "subnets", "known", "by", "the", "provider", "for", "the", "specified", "instance", "or", "list", "of", "ids", ".", "subnetIds", "can", "be", "empty", "in", "which", "case", "all", "known", "are", "returned", "." ]

[ "func", "(", "s", "Server", ")", "UseTargetServer", "(", "name", "string", ")", "(", "*", "Server", ",", "error", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "name", ")", "\n", "return", "NewServer", "(", "s", ".", "UseTarget", "(", "name", ")", ")", "\n", "}" ]

[ "UseTargetServer", "returns", "a", "new", "Server", "based", "on", "the", "input", "target", "node", "name", ".", "It", "is", "intended", "for", "use", "when", "operations", "must", "target", "specific", "nodes", "in", "a", "cluster", "." ]

[ "func", "NewMockEntityFinder", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockEntityFinder", "{", "mock", ":=", "&", "MockEntityFinder", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockEntityFinderMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "NewMockEntity", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockEntity", "{", "mock", ":=", "&", "MockEntity", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockEntityMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockEntityMockRecorder", ")", "Tag", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockEntity", ")", "(", "nil", ")", ".", "Tag", ")", ")", "\n", "}" ]

[ "Tag", "indicates", "an", "expected", "call", "of", "Tag" ]

[ "func", "NewMockLifer", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockLifer", "{", "mock", ":=", "&", "MockLifer", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockLiferMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "env", "*", "maasEnviron", ")", "checkForExistingDevice", "(", "params", "deviceCreatorParams", ")", "(", "gomaasapi", ".", "Device", ",", "error", ")", "{", "devicesArgs", ":=", "gomaasapi", ".", "DevicesArgs", "{", "Hostname", ":", "[", "]", "string", "{", "params", ".", "Name", "}", ",", "}", "\n", "maybeDevices", ",", "err", ":=", "params", ".", "Machine", ".", "Devices", "(", "devicesArgs", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "params", ".", "Name", ",", "err", ")", "\n", "// not considered fatal, since we'll attempt to create the device if we didn't find it", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "len", "(", "maybeDevices", ")", "==", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "params", ".", "Name", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "len", "(", "maybeDevices", ")", ">", "1", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "len", "(", "maybeDevices", ")", ",", "params", ".", "Name", ")", "\n", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "maybeDevices", ")", ",", "params", ".", "Name", ")", "\n", "}", "\n", "device", ":=", "maybeDevices", "[", "0", "]", "\n", "// Now validate that this device has the right interfaces", "matches", ",", "err", ":=", "validateExistingDevice", "(", "params", ".", "DesiredInterfaceInfo", ",", "device", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "matches", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "params", ".", "Name", ")", "\n", "return", "device", ",", "nil", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "params", ".", "Name", ")", "\n", "// We found a device, but it doesn't match what we need. remove it and we'll create again.", "device", ".", "Delete", "(", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "checkForExistingDevice", "checks", "to", "see", "if", "we", "ve", "already", "registered", "a", "device", "with", "this", "name", "and", "if", "its", "information", "is", "appropriately", "populated", ".", "If", "we", "have", "then", "we", "just", "return", "the", "existing", "interface", "info", ".", "If", "we", "find", "it", "but", "it", "doesn", "t", "match", "then", "we", "ask", "MAAS", "to", "remove", "it", "which", "should", "cause", "the", "calling", "code", "to", "create", "it", "again", "." ]

[ "func", "formatShowTabular", "(", "writer", "io", ".", "Writer", ",", "value", "interface", "{", "}", ")", "error", "{", "endpoints", ",", "ok", ":=", "value", ".", "(", "map", "[", "string", "]", "ShowOfferedApplication", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "endpoints", ",", "value", ")", "\n", "}", "\n", "return", "formatOfferedEndpointsTabular", "(", "writer", ",", "endpoints", ")", "\n", "}" ]

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

[ "func", "formatOfferedEndpointsTabular", "(", "writer", "io", ".", "Writer", ",", "all", "map", "[", "string", "]", "ShowOfferedApplication", ")", "error", "{", "tw", ":=", "output", ".", "TabWriter", "(", "writer", ")", "\n", "w", ":=", "output", ".", "Wrapper", "{", "tw", "}", "\n\n", "w", ".", "Println", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "for", "urlStr", ",", "one", ":=", "range", "all", "{", "url", ",", "err", ":=", "crossmodel", ".", "ParseOfferURL", "(", "urlStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "store", ":=", "url", ".", "Source", "\n", "url", ".", "Source", "=", "\"", "\"", "\n", "offerURL", ":=", "url", ".", "String", "(", ")", "\n", "offerAccess", ":=", "one", ".", "Access", "\n", "offerDesc", ":=", "one", ".", "Description", "\n\n", "// truncate long description for now.", "if", "len", "(", "offerDesc", ")", ">", "maxColumnLength", "{", "offerDesc", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "offerDesc", "[", ":", "maxFieldLength", "]", ",", "truncatedSuffix", ")", "\n", "}", "\n", "descLines", ":=", "breakLines", "(", "offerDesc", ")", "\n\n", "// Find the maximum amount of iterations required:", "// it will be either endpoints or description lines length", "maxIterations", ":=", "max", "(", "len", "(", "one", ".", "Endpoints", ")", ",", "len", "(", "descLines", ")", ")", "\n\n", "names", ":=", "[", "]", "string", "{", "}", "\n", "for", "name", ":=", "range", "one", ".", "Endpoints", "{", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "names", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "maxIterations", ";", "i", "++", "{", "descLine", ":=", "descAt", "(", "descLines", ",", "i", ")", "\n", "name", ",", "endpoint", ":=", "endpointAt", "(", "one", ".", "Endpoints", ",", "names", ",", "i", ")", "\n", "w", ".", "Println", "(", "store", ",", "offerURL", ",", "offerAccess", ",", "descLine", ",", "name", ",", "endpoint", ".", "Interface", ",", "endpoint", ".", "Role", ")", "\n", "// Only print once.", "store", "=", "\"", "\"", "\n", "offerURL", "=", "\"", "\"", "\n", "offerAccess", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "tw", ".", "Flush", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "formatOfferedEndpointsTabular", "returns", "a", "tabular", "summary", "of", "offered", "applications", "endpoints", "." ]

[ "func", "queryCloud", "(", "clouds", "[", "]", "string", ",", "defCloud", "string", ",", "scanner", "*", "bufio", ".", "Scanner", ",", "w", "io", ".", "Writer", ")", "(", "string", ",", "error", ")", "{", "list", ":=", "strings", ".", "Join", "(", "clouds", ",", "\"", "\\n", "\"", ")", "\n", "if", "_", ",", "err", ":=", "fmt", ".", "Fprint", "(", "w", ",", "\"", "\\n", "\"", ",", "list", ",", "\"", "\\n", "\\n", "\"", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// add support for a default (empty) selection.", "clouds", "=", "append", "(", "clouds", ",", "\"", "\"", ")", "\n\n", "verify", ":=", "interact", ".", "MatchOptions", "(", "clouds", ",", "\"", "\"", ")", "\n\n", "query", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "defCloud", ")", "\n", "cloud", ",", "err", ":=", "interact", ".", "QueryVerify", "(", "query", ",", "scanner", ",", "w", ",", "w", ",", "verify", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "cloud", "==", "\"", "\"", "{", "return", "defCloud", ",", "nil", "\n", "}", "\n", "if", "ok", ":=", "names", ".", "IsValidCloud", "(", "cloud", ")", ";", "!", "ok", "{", "return", "\"", "\"", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "cloud", ")", "\n", "}", "\n\n", "cloudName", ",", "ok", ":=", "interact", ".", "FindMatch", "(", "cloud", ",", "clouds", ")", "\n", "if", "!", "ok", "{", "// should be impossible", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "cloud", ")", "\n", "}", "\n\n", "return", "cloudName", ",", "nil", "\n", "}" ]

[ "queryCloud", "asks", "the", "user", "to", "choose", "a", "cloud", "." ]

[ "func", "queryRegion", "(", "cloud", "string", ",", "regions", "[", "]", "jujucloud", ".", "Region", ",", "scanner", "*", "bufio", ".", "Scanner", ",", "w", "io", ".", "Writer", ")", "(", "string", ",", "error", ")", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "cloud", ")", "\n", "names", ":=", "jujucloud", ".", "RegionNames", "(", "regions", ")", "\n", "// add an empty string to allow for a default value. Also gives us an extra", "// line return after the list of names.", "names", "=", "append", "(", "names", ",", "\"", "\"", ")", "\n", "if", "_", ",", "err", ":=", "fmt", ".", "Fprintln", "(", "w", ",", "strings", ".", "Join", "(", "names", ",", "\"", "\\n", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "verify", ":=", "interact", ".", "MatchOptions", "(", "names", ",", "\"", "\"", ")", "\n", "defaultRegion", ":=", "regions", "[", "0", "]", ".", "Name", "\n", "query", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cloud", ",", "defaultRegion", ")", "\n", "region", ",", "err", ":=", "interact", ".", "QueryVerify", "(", "query", ",", "scanner", ",", "w", ",", "w", ",", "verify", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "region", "==", "\"", "\"", "{", "return", "defaultRegion", ",", "nil", "\n", "}", "\n", "regionName", ",", "ok", ":=", "interact", ".", "FindMatch", "(", "region", ",", "names", ")", "\n", "if", "!", "ok", "{", "// should be impossible", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "region", ")", "\n", "}", "\n\n", "return", "regionName", ",", "nil", "\n", "}" ]

[ "queryRegion", "asks", "the", "user", "to", "pick", "a", "region", "of", "the", "ones", "passed", "in", ".", "The", "first", "region", "in", "the", "list", "will", "be", "the", "default", "." ]

[ "func", "(", "s", "*", "relationsResolver", ")", "NextOp", "(", "localState", "resolver", ".", "LocalState", ",", "remoteState", "remotestate", ".", "Snapshot", ",", "opFactory", "operation", ".", "Factory", ",", ")", "(", "operation", ".", "Operation", ",", "error", ")", "{", "hook", ",", "err", ":=", "s", ".", "relations", ".", "NextHook", "(", "localState", ",", "remoteState", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "opFactory", ".", "NewRunHook", "(", "hook", ")", "\n", "}" ]

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

[ "func", "NewRelations", "(", "config", "RelationsConfig", ")", "(", "Relations", ",", "error", ")", "{", "unit", ",", "err", ":=", "config", ".", "State", ".", "Unit", "(", "config", ".", "UnitTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "principalName", ",", "subordinate", ",", "err", ":=", "unit", ".", "PrincipalName", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "leadershipContext", ":=", "config", ".", "NewLeadershipContext", "(", "config", ".", "State", ".", "LeadershipSettings", ",", "config", ".", "Tracker", ",", "config", ".", "UnitTag", ".", "Id", "(", ")", ",", ")", "\n", "r", ":=", "&", "relations", "{", "st", ":", "config", ".", "State", ",", "unit", ":", "unit", ",", "leaderCtx", ":", "leadershipContext", ",", "subordinate", ":", "subordinate", ",", "principalName", ":", "principalName", ",", "charmDir", ":", "config", ".", "CharmDir", ",", "relationsDir", ":", "config", ".", "RelationsDir", ",", "relationers", ":", "make", "(", "map", "[", "int", "]", "*", "Relationer", ")", ",", "abort", ":", "config", ".", "Abort", ",", "}", "\n", "if", "err", ":=", "r", ".", "init", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "r", ",", "nil", "\n", "}" ]

[ "NewRelations", "returns", "a", "new", "Relations", "instance", "." ]

[ "func", "(", "r", "*", "relations", ")", "NextHook", "(", "localState", "resolver", ".", "LocalState", ",", "remoteState", "remotestate", ".", "Snapshot", ",", ")", "(", "hook", ".", "Info", ",", "error", ")", "{", "if", "remoteState", ".", "Life", "==", "params", ".", "Dying", "{", "// The unit is Dying, so make sure all subordinates are dying.", "var", "destroyAllSubordinates", "bool", "\n", "for", "relationId", ",", "relationSnapshot", ":=", "range", "remoteState", ".", "Relations", "{", "if", "relationSnapshot", ".", "Life", "!=", "params", ".", "Alive", "{", "continue", "\n", "}", "\n", "relationer", ",", "ok", ":=", "r", ".", "relationers", "[", "relationId", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "if", "relationer", ".", "ru", ".", "Endpoint", "(", ")", ".", "Scope", "==", "corecharm", ".", "ScopeContainer", "{", "relationSnapshot", ".", "Life", "=", "params", ".", "Dying", "\n", "remoteState", ".", "Relations", "[", "relationId", "]", "=", "relationSnapshot", "\n", "destroyAllSubordinates", "=", "true", "\n", "}", "\n", "}", "\n", "if", "destroyAllSubordinates", "{", "if", "err", ":=", "r", ".", "unit", ".", "DestroyAllSubordinates", "(", ")", ";", "err", "!=", "nil", "{", "return", "hook", ".", "Info", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Add/remove local relation state; enter and leave scope as necessary.", "if", "err", ":=", "r", ".", "update", "(", "remoteState", ".", "Relations", ")", ";", "err", "!=", "nil", "{", "return", "hook", ".", "Info", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "localState", ".", "Kind", "!=", "operation", ".", "Continue", "{", "return", "hook", ".", "Info", "{", "}", ",", "resolver", ".", "ErrNoOperation", "\n", "}", "\n\n", "// See if any of the relations have operations to perform.", "for", "relationId", ",", "relationSnapshot", ":=", "range", "remoteState", ".", "Relations", "{", "relationer", ",", "ok", ":=", "r", ".", "relationers", "[", "relationId", "]", "\n", "if", "!", "ok", "||", "relationer", ".", "IsImplicit", "(", ")", "{", "continue", "\n", "}", "\n", "var", "remoteBroken", "bool", "\n", "if", "remoteState", ".", "Life", "==", "params", ".", "Dying", "||", "relationSnapshot", ".", "Life", "==", "params", ".", "Dying", "||", "relationSnapshot", ".", "Suspended", "{", "relationSnapshot", "=", "remotestate", ".", "RelationSnapshot", "{", "}", "\n", "remoteBroken", "=", "true", "\n", "// TODO(axw) if relation is implicit, leave scope & remove.", "}", "\n", "// If either the unit or the relation are Dying, or the relation becomes suspended,", "// then the relation should be broken.", "hook", ",", "err", ":=", "nextRelationHook", "(", "relationer", ".", "dir", ",", "relationSnapshot", ",", "remoteBroken", ")", "\n", "if", "err", "==", "resolver", ".", "ErrNoOperation", "{", "continue", "\n", "}", "\n", "return", "hook", ",", "err", "\n", "}", "\n", "return", "hook", ".", "Info", "{", "}", ",", "resolver", ".", "ErrNoOperation", "\n", "}" ]

[ "NextHook", "implements", "Relations", "." ]

[ "func", "nextRelationHook", "(", "dir", "*", "StateDir", ",", "remote", "remotestate", ".", "RelationSnapshot", ",", "remoteBroken", "bool", ",", ")", "(", "hook", ".", "Info", ",", "error", ")", "{", "local", ":=", "dir", ".", "State", "(", ")", "\n", "// If there's a guaranteed next hook, return that.", "relationId", ":=", "local", ".", "RelationId", "\n", "if", "local", ".", "ChangedPending", "!=", "\"", "\"", "{", "unitName", ":=", "local", ".", "ChangedPending", "\n", "return", "hook", ".", "Info", "{", "Kind", ":", "hooks", ".", "RelationChanged", ",", "RelationId", ":", "relationId", ",", "RemoteUnit", ":", "unitName", ",", "ChangeVersion", ":", "remote", ".", "Members", "[", "unitName", "]", ",", "}", ",", "nil", "\n", "}", "\n\n", "// Get the union of all relevant units, and sort them, so we produce events", "// in a consistent order (largely for the convenience of the tests).", "allUnitNames", ":=", "set", ".", "NewStrings", "(", ")", "\n", "for", "unitName", ":=", "range", "local", ".", "Members", "{", "allUnitNames", ".", "Add", "(", "unitName", ")", "\n", "}", "\n", "for", "unitName", ":=", "range", "remote", ".", "Members", "{", "allUnitNames", ".", "Add", "(", "unitName", ")", "\n", "}", "\n", "sortedUnitNames", ":=", "allUnitNames", ".", "SortedValues", "(", ")", "\n\n", "// If there are any locally known units that are no longer reflected in", "// remote state, depart them.", "for", "_", ",", "unitName", ":=", "range", "sortedUnitNames", "{", "changeVersion", ",", "found", ":=", "local", ".", "Members", "[", "unitName", "]", "\n", "if", "!", "found", "{", "continue", "\n", "}", "\n", "if", "_", ",", "found", ":=", "remote", ".", "Members", "[", "unitName", "]", ";", "!", "found", "{", "return", "hook", ".", "Info", "{", "Kind", ":", "hooks", ".", "RelationDeparted", ",", "RelationId", ":", "relationId", ",", "RemoteUnit", ":", "unitName", ",", "ChangeVersion", ":", "changeVersion", ",", "}", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// If the relation's meant to be broken, break it.", "if", "remoteBroken", "{", "if", "!", "dir", ".", "Exists", "(", ")", "{", "// The relation may have been suspended and then removed, so we", "// don't want to run the hook twice.", "return", "hook", ".", "Info", "{", "}", ",", "resolver", ".", "ErrNoOperation", "\n", "}", "\n", "return", "hook", ".", "Info", "{", "Kind", ":", "hooks", ".", "RelationBroken", ",", "RelationId", ":", "relationId", ",", "}", ",", "nil", "\n", "}", "\n\n", "// If there are any remote units not locally known, join them.", "for", "_", ",", "unitName", ":=", "range", "sortedUnitNames", "{", "changeVersion", ",", "found", ":=", "remote", ".", "Members", "[", "unitName", "]", "\n", "if", "!", "found", "{", "continue", "\n", "}", "\n", "if", "_", ",", "found", ":=", "local", ".", "Members", "[", "unitName", "]", ";", "!", "found", "{", "return", "hook", ".", "Info", "{", "Kind", ":", "hooks", ".", "RelationJoined", ",", "RelationId", ":", "relationId", ",", "RemoteUnit", ":", "unitName", ",", "ChangeVersion", ":", "changeVersion", ",", "}", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Finally scan for remote units whose latest version is not reflected", "// in local state.", "for", "_", ",", "unitName", ":=", "range", "sortedUnitNames", "{", "remoteChangeVersion", ",", "found", ":=", "remote", ".", "Members", "[", "unitName", "]", "\n", "if", "!", "found", "{", "continue", "\n", "}", "\n", "localChangeVersion", ",", "found", ":=", "local", ".", "Members", "[", "unitName", "]", "\n", "if", "!", "found", "{", "continue", "\n", "}", "\n", "// NOTE(axw) we use != and not > to cater due to the", "// use of the relation settings document's txn-revno", "// as the version. When model-uuid migration occurs, the", "// document is recreated, resetting txn-revno.", "if", "remoteChangeVersion", "!=", "localChangeVersion", "{", "return", "hook", ".", "Info", "{", "Kind", ":", "hooks", ".", "RelationChanged", ",", "RelationId", ":", "relationId", ",", "RemoteUnit", ":", "unitName", ",", "ChangeVersion", ":", "remoteChangeVersion", ",", "}", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Nothing left to do for this relation.", "return", "hook", ".", "Info", "{", "}", ",", "resolver", ".", "ErrNoOperation", "\n", "}" ]

[ "nextRelationHook", "returns", "the", "next", "hook", "op", "that", "should", "be", "executed", "in", "the", "relation", "characterised", "by", "the", "supplied", "local", "and", "remote", "state", ";", "or", "an", "error", "if", "the", "states", "do", "not", "refer", "to", "the", "same", "relation", ";", "or", "ErrRelationUpToDate", "if", "no", "hooks", "need", "to", "be", "executed", "." ]

[ "func", "(", "r", "*", "relations", ")", "Name", "(", "id", "int", ")", "(", "string", ",", "error", ")", "{", "relationer", ",", "found", ":=", "r", ".", "relationers", "[", "id", "]", "\n", "if", "!", "found", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "return", "relationer", ".", "ru", ".", "Endpoint", "(", ")", ".", "Name", ",", "nil", "\n", "}" ]

[ "Name", "is", "part", "of", "the", "Relations", "interface", "." ]

[ "func", "(", "r", "*", "relations", ")", "PrepareHook", "(", "hookInfo", "hook", ".", "Info", ")", "(", "string", ",", "error", ")", "{", "if", "!", "hookInfo", ".", "Kind", ".", "IsRelation", "(", ")", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "hookInfo", ")", "\n", "}", "\n", "relationer", ",", "found", ":=", "r", ".", "relationers", "[", "hookInfo", ".", "RelationId", "]", "\n", "if", "!", "found", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "hookInfo", ".", "RelationId", ")", "\n", "}", "\n", "return", "relationer", ".", "PrepareHook", "(", "hookInfo", ")", "\n", "}" ]

[ "PrepareHook", "is", "part", "of", "the", "Relations", "interface", "." ]

[ "func", "(", "r", "*", "relations", ")", "CommitHook", "(", "hookInfo", "hook", ".", "Info", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "&&", "hookInfo", ".", "Kind", "==", "hooks", ".", "RelationBroken", "{", "delete", "(", "r", ".", "relationers", ",", "hookInfo", ".", "RelationId", ")", "\n", "}", "\n", "}", "(", ")", "\n", "if", "!", "hookInfo", ".", "Kind", ".", "IsRelation", "(", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "hookInfo", ")", "\n", "}", "\n", "relationer", ",", "found", ":=", "r", ".", "relationers", "[", "hookInfo", ".", "RelationId", "]", "\n", "if", "!", "found", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "hookInfo", ".", "RelationId", ")", "\n", "}", "\n", "return", "relationer", ".", "CommitHook", "(", "hookInfo", ")", "\n", "}" ]

[ "CommitHook", "is", "part", "of", "the", "Relations", "interface", "." ]