Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13k

[ "func", "(", "st", "*", "State", ")", "AddSpace", "(", "name", "string", ",", "providerId", "network", ".", "Id", ",", "subnets", "[", "]", "string", ",", "isPublic", "bool", ")", "(", "newSpace", "*", "Space", ",", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "name", ")", "\n", "if", "!", "names", ".", "IsValidSpace", "(", "name", ")", "{", "return", "nil", ",", "errors", ".", "NewNotValid", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "spaceDoc", ":=", "spaceDoc", "{", "Life", ":", "Alive", ",", "Name", ":", "name", ",", "IsPublic", ":", "isPublic", ",", "ProviderId", ":", "string", "(", "providerId", ")", ",", "}", "\n", "newSpace", "=", "&", "Space", "{", "doc", ":", "spaceDoc", ",", "st", ":", "st", "}", "\n\n", "ops", ":=", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "spacesC", ",", "Id", ":", "name", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "spaceDoc", ",", "}", "}", "\n\n", "if", "providerId", "!=", "\"", "\"", "{", "ops", "=", "append", "(", "ops", ",", "st", ".", "networkEntityGlobalKeyOp", "(", "\"", "\"", ",", "providerId", ")", ")", "\n", "}", "\n\n", "for", "_", ",", "subnetId", ":=", "range", "subnets", "{", "// TODO:(mfoord) once we have refcounting for subnets we should", "// also assert that the refcount is zero as moving the space of a", "// subnet in use is not permitted.", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "subnetsC", ",", "Id", ":", "subnetId", ",", "Assert", ":", "bson", ".", "D", "{", "bson", ".", "DocElem", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "false", "}", "}", "}", "}", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "name", "}", "}", "}", "}", ",", "}", ")", "\n", "}", "\n\n", "if", "err", ":=", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", ";", "err", "==", "txn", ".", "ErrAborted", "{", "if", "_", ",", "err", ":=", "st", ".", "Space", "(", "name", ")", ";", "err", "==", "nil", "{", "return", "nil", ",", "errors", ".", "AlreadyExistsf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "for", "_", ",", "subnetId", ":=", "range", "subnets", "{", "subnet", ",", "err", ":=", "st", ".", "Subnet", "(", "subnetId", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "subnet", ".", "FanLocalUnderlay", "(", ")", "!=", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "subnet", ".", "CIDR", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "newSpace", ".", "Refresh", "(", ")", ";", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "providerId", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "newSpace", ",", "nil", "\n", "}" ]

[ "AddSpace", "creates", "and", "returns", "a", "new", "space", "." ]

[ "func", "(", "st", "*", "State", ")", "Space", "(", "name", "string", ")", "(", "*", "Space", ",", "error", ")", "{", "spaces", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "spacesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "doc", "spaceDoc", "\n", "err", ":=", "spaces", ".", "FindId", "(", "name", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "return", "&", "Space", "{", "st", ",", "doc", "}", ",", "nil", "\n", "}" ]

[ "Space", "returns", "a", "space", "from", "state", "that", "matches", "the", "provided", "name", ".", "An", "error", "is", "returned", "if", "the", "space", "doesn", "t", "exist", "or", "if", "there", "was", "a", "problem", "accessing", "its", "information", "." ]

[ "func", "(", "st", "*", "State", ")", "AllSpaces", "(", ")", "(", "[", "]", "*", "Space", ",", "error", ")", "{", "spacesCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "spacesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "docs", ":=", "[", "]", "spaceDoc", "{", "}", "\n", "err", ":=", "spacesCollection", ".", "Find", "(", "nil", ")", ".", "All", "(", "&", "docs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "spaces", ":=", "make", "(", "[", "]", "*", "Space", ",", "len", "(", "docs", ")", ")", "\n", "for", "i", ",", "doc", ":=", "range", "docs", "{", "spaces", "[", "i", "]", "=", "&", "Space", "{", "st", ":", "st", ",", "doc", ":", "doc", "}", "\n", "}", "\n", "return", "spaces", ",", "nil", "\n", "}" ]

[ "AllSpaces", "returns", "all", "spaces", "for", "the", "model", "." ]

[ "func", "(", "s", "*", "Space", ")", "EnsureDead", "(", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "s", ")", "\n\n", "if", "s", ".", "doc", ".", "Life", "==", "Dead", "{", "return", "nil", "\n", "}", "\n\n", "ops", ":=", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "spacesC", ",", "Id", ":", "s", ".", "doc", ".", "Name", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "Dead", "}", "}", "}", "}", ",", "Assert", ":", "isAliveDoc", ",", "}", "}", "\n\n", "txnErr", ":=", "s", ".", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", "\n", "if", "txnErr", "==", "nil", "{", "s", ".", "doc", ".", "Life", "=", "Dead", "\n", "return", "nil", "\n", "}", "\n", "return", "onAbort", "(", "txnErr", ",", "spaceNotAliveErr", ")", "\n", "}" ]

[ "EnsureDead", "sets", "the", "Life", "of", "the", "space", "to", "Dead", "if", "it", "s", "Alive", ".", "If", "the", "space", "is", "already", "Dead", "no", "error", "is", "returned", ".", "When", "the", "space", "is", "no", "longer", "Alive", "or", "already", "removed", "errNotAlive", "is", "returned", "." ]

[ "func", "(", "s", "*", "Space", ")", "Remove", "(", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "s", ")", "\n\n", "if", "s", ".", "doc", ".", "Life", "!=", "Dead", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ops", ":=", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "spacesC", ",", "Id", ":", "s", ".", "doc", ".", "Name", ",", "Remove", ":", "true", ",", "Assert", ":", "isDeadDoc", ",", "}", "}", "\n", "if", "s", ".", "ProviderId", "(", ")", "!=", "\"", "\"", "{", "ops", "=", "append", "(", "ops", ",", "s", ".", "st", ".", "networkEntityGlobalKeyRemoveOp", "(", "\"", "\"", ",", "s", ".", "ProviderId", "(", ")", ")", ")", "\n", "}", "\n\n", "txnErr", ":=", "s", ".", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", "\n", "if", "txnErr", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "onAbort", "(", "txnErr", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}" ]

[ "Remove", "removes", "a", "Dead", "space", ".", "If", "the", "space", "is", "not", "Dead", "or", "it", "is", "already", "removed", "an", "error", "is", "returned", "." ]

[ "func", "NewMockUpgradeSeriesBackend", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockUpgradeSeriesBackend", "{", "mock", ":=", "&", "MockUpgradeSeriesBackend", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockUpgradeSeriesBackendMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "NewMockUpgradeSeriesMachine", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockUpgradeSeriesMachine", "{", "mock", ":=", "&", "MockUpgradeSeriesMachine", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockUpgradeSeriesMachineMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "RemoveUpgradeSeriesLock", "(", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "RemoveUpgradeSeriesLock", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockUpgradeSeriesMachineMockRecorder", ")", "RemoveUpgradeSeriesLock", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockUpgradeSeriesMachine", ")", "(", "nil", ")", ".", "RemoveUpgradeSeriesLock", ")", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "Series", "(", ")", "string", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "string", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Series", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "SetUpgradeSeriesStatus", "(", "arg0", "model", ".", "UpgradeSeriesStatus", ",", "arg1", "string", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SetUpgradeSeriesStatus", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "StartUpgradeSeriesUnitCompletion", "(", "arg0", "string", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "StartUpgradeSeriesUnitCompletion", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "UpdateMachineSeries", "(", "arg0", "string", ",", "arg1", "bool", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "UpdateMachineSeries", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "UpgradeSeriesStatus", "(", ")", "(", "model", ".", "UpgradeSeriesStatus", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "model", ".", "UpgradeSeriesStatus", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "UpgradeSeriesStatus", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "UpgradeSeriesTarget", "(", ")", "(", "string", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "string", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "UpgradeSeriesTarget", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockUpgradeSeriesMachine", ")", "UpgradeSeriesUnitStatuses", "(", ")", "(", "map", "[", "string", "]", "state", ".", "UpgradeSeriesUnitStatus", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "map", "[", "string", "]", "state", ".", "UpgradeSeriesUnitStatus", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "UpgradeSeriesUnitStatuses", "mocks", "base", "method" ]

[ "func", "NewMockUpgradeSeriesUnit", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockUpgradeSeriesUnit", "{", "mock", ":=", "&", "MockUpgradeSeriesUnit", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockUpgradeSeriesUnitMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockUpgradeSeriesUnitMockRecorder", ")", "UpgradeSeriesStatus", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockUpgradeSeriesUnit", ")", "(", "nil", ")", ".", "UpgradeSeriesStatus", ")", ")", "\n", "}" ]

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

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

[ "RegisterContainerProvider", "is", "used", "for", "providers", "that", "we", "want", "to", "use", "for", "managing", "instances", "but", "are", "not", "possible", "sources", "for", "juju", "bootstrap", "." ]

[ "func", "Open", "(", "p", "environs", ".", "EnvironProvider", ",", "args", "environs", ".", "OpenParams", ")", "(", "Broker", ",", "error", ")", "{", "if", "envProvider", ",", "ok", ":=", "p", ".", "(", "ContainerEnvironProvider", ")", ";", "!", "ok", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "p", ")", "\n", "}", "else", "{", "return", "envProvider", ".", "Open", "(", "args", ")", "\n", "}", "\n", "}" ]

[ "Open", "creates", "a", "Broker", "instance", "and", "errors", "if", "the", "provider", "is", "not", "for", "a", "container", "substrate", "." ]

[ "func", "DeployApplication", "(", "st", "ApplicationDeployer", ",", "args", "DeployApplicationParams", ")", "(", "Application", ",", "error", ")", "{", "charmConfig", ",", "err", ":=", "args", ".", "Charm", ".", "Config", "(", ")", ".", "ValidateSettings", "(", "args", ".", "CharmConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "args", ".", "Charm", ".", "Meta", "(", ")", ".", "Subordinate", "{", "if", "args", ".", "NumUnits", "!=", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "constraints", ".", "IsEmpty", "(", "&", "args", ".", "Constraints", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "// TODO(fwereade): transactional State.AddApplication including settings, constraints", "// (minimumUnitCount, initialMachineIds?).", "effectiveBindings", ",", "err", ":=", "getEffectiveBindingsForCharmMeta", "(", "args", ".", "Charm", ".", "Meta", "(", ")", ",", "args", ".", "EndpointBindings", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "asa", ":=", "state", ".", "AddApplicationArgs", "{", "Name", ":", "args", ".", "ApplicationName", ",", "Series", ":", "args", ".", "Series", ",", "Charm", ":", "args", ".", "Charm", ",", "Channel", ":", "args", ".", "Channel", ",", "Storage", ":", "stateStorageConstraints", "(", "args", ".", "Storage", ")", ",", "Devices", ":", "stateDeviceConstraints", "(", "args", ".", "Devices", ")", ",", "AttachStorage", ":", "args", ".", "AttachStorage", ",", "ApplicationConfig", ":", "args", ".", "ApplicationConfig", ",", "CharmConfig", ":", "charmConfig", ",", "NumUnits", ":", "args", ".", "NumUnits", ",", "Placement", ":", "args", ".", "Placement", ",", "Resources", ":", "args", ".", "Resources", ",", "EndpointBindings", ":", "effectiveBindings", ",", "}", "\n\n", "if", "!", "args", ".", "Charm", ".", "Meta", "(", ")", ".", "Subordinate", "{", "asa", ".", "Constraints", "=", "args", ".", "Constraints", "\n", "}", "\n", "return", "st", ".", "AddApplication", "(", "asa", ")", "\n", "}" ]

[ "DeployApplication", "takes", "a", "charm", "and", "various", "parameters", "and", "deploys", "it", "." ]

[ "func", "addUnits", "(", "unitAdder", "UnitAdder", ",", "appName", "string", ",", "n", "int", ",", "placement", "[", "]", "*", "instance", ".", "Placement", ",", "attachStorage", "[", "]", "names", ".", "StorageTag", ",", "assignUnits", "bool", ",", ")", "(", "[", "]", "Unit", ",", "error", ")", "{", "units", ":=", "make", "(", "[", "]", "Unit", ",", "n", ")", "\n", "// Hard code for now till we implement a different approach.", "policy", ":=", "state", ".", "AssignCleanEmpty", "\n", "// TODO what do we do if we fail half-way through this process?", "for", "i", ":=", "0", ";", "i", "<", "n", ";", "i", "++", "{", "unit", ",", "err", ":=", "unitAdder", ".", "AddUnit", "(", "state", ".", "AddUnitParams", "{", "AttachStorage", ":", "attachStorage", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "i", "+", "1", ",", "n", ",", "appName", ")", "\n", "}", "\n", "units", "[", "i", "]", "=", "unit", "\n", "if", "!", "assignUnits", "{", "continue", "\n", "}", "\n\n", "// Are there still placement directives to use?", "if", "i", ">", "len", "(", "placement", ")", "-", "1", "{", "if", "err", ":=", "unit", ".", "AssignWithPolicy", "(", "policy", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "if", "err", ":=", "unit", ".", "AssignWithPlacement", "(", "placement", "[", "i", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "unit", ".", "UnitTag", "(", ")", ".", "Id", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "units", ",", "nil", "\n", "}" ]

[ "addUnits", "starts", "n", "units", "of", "the", "given", "application", "using", "the", "specified", "placement", "directives", "to", "allocate", "the", "machines", "." ]

[ "func", "(", "c", "*", "BootstrapCommand", ")", "Info", "(", ")", "*", "cmd", ".", "Info", "{", "return", "jujucmd", ".", "Info", "(", "&", "cmd", ".", "Info", "{", "Name", ":", "\"", "\"", ",", "Purpose", ":", "\"", "\"", ",", "}", ")", "\n", "}" ]

[ "Info", "returns", "a", "description", "of", "the", "command", "." ]

[ "func", "(", "c", "*", "BootstrapCommand", ")", "SetFlags", "(", "f", "*", "gnuflag", ".", "FlagSet", ")", "{", "c", ".", "AgentConf", ".", "AddFlags", "(", "f", ")", "\n", "f", ".", "DurationVar", "(", "&", "c", ".", "Timeout", ",", "\"", "\"", ",", "time", ".", "Duration", "(", "0", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "SetFlags", "adds", "the", "flags", "for", "this", "command", "to", "the", "passed", "gnuflag", ".", "FlagSet", "." ]

[ "func", "(", "c", "*", "BootstrapCommand", ")", "populateTools", "(", "st", "*", "state", ".", "State", ",", "env", "environs", ".", "BootstrapEnviron", ")", "error", "{", "agentConfig", ":=", "c", ".", "CurrentConfig", "(", ")", "\n", "dataDir", ":=", "agentConfig", ".", "DataDir", "(", ")", "\n\n", "hostSeries", ",", "err", ":=", "series", ".", "HostSeries", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "current", ":=", "version", ".", "Binary", "{", "Number", ":", "jujuversion", ".", "Current", ",", "Arch", ":", "arch", ".", "HostArch", "(", ")", ",", "Series", ":", "hostSeries", ",", "}", "\n", "tools", ",", "err", ":=", "agenttools", ".", "ReadTools", "(", "dataDir", ",", "current", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "data", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filepath", ".", "Join", "(", "agenttools", ".", "SharedToolsDir", "(", "dataDir", ",", "current", ")", ",", "\"", "\"", ",", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "toolstorage", ",", "err", ":=", "st", ".", "ToolsStorage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "toolstorage", ".", "Close", "(", ")", "\n\n", "var", "toolsVersions", "[", "]", "version", ".", "Binary", "\n", "if", "strings", ".", "HasPrefix", "(", "tools", ".", "URL", ",", "\"", "\"", ")", "{", "// Tools were uploaded: clone for each series of the same OS.", "os", ",", "err", ":=", "series", ".", "GetOSFromSeries", "(", "tools", ".", "Version", ".", "Series", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "osSeries", ":=", "series", ".", "OSSupportedSeries", "(", "os", ")", "\n", "for", "_", ",", "series", ":=", "range", "osSeries", "{", "toolsVersion", ":=", "tools", ".", "Version", "\n", "toolsVersion", ".", "Series", "=", "series", "\n", "toolsVersions", "=", "append", "(", "toolsVersions", ",", "toolsVersion", ")", "\n", "}", "\n", "}", "else", "{", "// Tools were downloaded from an external source: don't clone.", "toolsVersions", "=", "[", "]", "version", ".", "Binary", "{", "tools", ".", "Version", "}", "\n", "}", "\n\n", "for", "_", ",", "toolsVersion", ":=", "range", "toolsVersions", "{", "metadata", ":=", "binarystorage", ".", "Metadata", "{", "Version", ":", "toolsVersion", ".", "String", "(", ")", ",", "Size", ":", "tools", ".", "Size", ",", "SHA256", ":", "tools", ".", "SHA256", ",", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "toolsVersion", ")", "\n", "if", "err", ":=", "toolstorage", ".", "Add", "(", "bytes", ".", "NewReader", "(", "data", ")", ",", "metadata", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "populateTools", "stores", "uploaded", "tools", "in", "provider", "storage", "and", "updates", "the", "tools", "metadata", "." ]

[ "func", "(", "c", "*", "BootstrapCommand", ")", "populateGUIArchive", "(", "st", "*", "state", ".", "State", ",", "env", "environs", ".", "BootstrapEnviron", ")", "error", "{", "agentConfig", ":=", "c", ".", "CurrentConfig", "(", ")", "\n", "dataDir", ":=", "agentConfig", ".", "DataDir", "(", ")", "\n", "guistorage", ",", "err", ":=", "st", ".", "GUIStorage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "guistorage", ".", "Close", "(", ")", "\n", "gui", ",", "err", ":=", "agenttools", ".", "ReadGUIArchive", "(", "dataDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "f", ",", "err", ":=", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "agenttools", ".", "SharedGUIDir", "(", "dataDir", ")", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "if", "err", ":=", "guistorage", ".", "Add", "(", "f", ",", "binarystorage", ".", "Metadata", "{", "Version", ":", "gui", ".", "Version", ".", "String", "(", ")", ",", "Size", ":", "gui", ".", "Size", ",", "SHA256", ":", "gui", ".", "SHA256", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "=", "st", ".", "GUISetVersion", "(", "gui", ".", "Version", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "populateGUIArchive", "stores", "the", "uploaded", "Juju", "GUI", "archive", "in", "provider", "storage", "updates", "the", "GUI", "metadata", "and", "set", "the", "current", "Juju", "GUI", "version", "." ]

[ "func", "(", "c", "*", "BootstrapCommand", ")", "saveCustomImageMetadata", "(", "st", "*", "state", ".", "State", ",", "env", "environs", ".", "BootstrapEnviron", ",", "imageMetadata", "[", "]", "*", "imagemetadata", ".", "ImageMetadata", ")", "error", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "storeImageMetadataInState", "(", "st", ",", "env", ",", "\"", "\"", ",", "simplestreams", ".", "CUSTOM_CLOUD_DATA", ",", "imageMetadata", ")", "\n", "}" ]

[ "saveCustomImageMetadata", "stores", "the", "custom", "image", "metadata", "to", "the", "database" ]

[ "func", "storeImageMetadataInState", "(", "st", "*", "state", ".", "State", ",", "env", "environs", ".", "BootstrapEnviron", ",", "source", "string", ",", "priority", "int", ",", "existingMetadata", "[", "]", "*", "imagemetadata", ".", "ImageMetadata", ")", "error", "{", "if", "len", "(", "existingMetadata", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "cfg", ":=", "env", ".", "Config", "(", ")", "\n", "metadataState", ":=", "make", "(", "[", "]", "cloudimagemetadata", ".", "Metadata", ",", "len", "(", "existingMetadata", ")", ")", "\n", "for", "i", ",", "one", ":=", "range", "existingMetadata", "{", "m", ":=", "cloudimagemetadata", ".", "Metadata", "{", "MetadataAttributes", ":", "cloudimagemetadata", ".", "MetadataAttributes", "{", "Stream", ":", "one", ".", "Stream", ",", "Region", ":", "one", ".", "RegionName", ",", "Arch", ":", "one", ".", "Arch", ",", "VirtType", ":", "one", ".", "VirtType", ",", "RootStorageType", ":", "one", ".", "Storage", ",", "Source", ":", "source", ",", "Version", ":", "one", ".", "Version", ",", "}", ",", "Priority", ":", "priority", ",", "ImageId", ":", "one", ".", "Id", ",", "}", "\n", "s", ",", "err", ":=", "seriesFromVersion", "(", "one", ".", "Version", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "one", ".", "Version", ")", "\n", "}", "\n", "m", ".", "Series", "=", "s", "\n", "if", "m", ".", "Stream", "==", "\"", "\"", "{", "m", ".", "Stream", "=", "cfg", ".", "ImageStream", "(", ")", "\n", "}", "\n", "if", "m", ".", "Source", "==", "\"", "\"", "{", "m", ".", "Source", "=", "\"", "\"", "\n", "}", "\n", "metadataState", "[", "i", "]", "=", "m", "\n", "}", "\n", "if", "err", ":=", "st", ".", "CloudImageMetadataStorage", ".", "SaveMetadataNoExpiry", "(", "metadataState", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "storeImageMetadataInState", "writes", "image", "metadata", "into", "state", "store", "." ]

[ "func", "NewWorker", "(", ")", "worker", ".", "Worker", "{", "var", "w", "terminationWorker", "\n", "c", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "c", ",", "TerminationSignal", ")", "\n", "w", ".", "tomb", ".", "Go", "(", "func", "(", ")", "error", "{", "defer", "signal", ".", "Stop", "(", "c", ")", "\n", "return", "w", ".", "loop", "(", "c", ")", "\n", "}", ")", "\n", "return", "&", "w", "\n", "}" ]

[ "NewWorker", "returns", "a", "worker", "that", "waits", "for", "a", "TerminationSignal", "signal", "and", "then", "exits", "with", "worker", ".", "ErrTerminateAgent", "." ]

[ "func", "NewListCommand", "(", ")", "cmd", ".", "Command", "{", "cmd", ":=", "&", "listCommand", "{", "}", "\n", "cmd", ".", "newAPIFunc", "=", "func", "(", ")", "(", "StorageListAPI", ",", "error", ")", "{", "return", "cmd", ".", "NewStorageAPI", "(", ")", "\n", "}", "\n", "return", "modelcmd", ".", "Wrap", "(", "cmd", ")", "\n", "}" ]

[ "NewListCommand", "returns", "a", "command", "for", "listing", "storage", "instances", "." ]

[ "func", "GetCombinedStorageInfo", "(", "p", "GetCombinedStorageInfoParams", ")", "(", "*", "CombinedStorage", ",", "error", ")", "{", "combined", ":=", "&", "CombinedStorage", "{", "}", "\n", "if", "p", ".", "WantFilesystems", "{", "filesystems", ",", "err", ":=", "generateListFilesystemsOutput", "(", "p", ".", "Context", ",", "p", ".", "APIClient", ",", "p", ".", "Ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "combined", ".", "Filesystems", "=", "filesystems", "\n", "}", "\n", "if", "p", ".", "WantVolumes", "{", "volumes", ",", "err", ":=", "generateListVolumeOutput", "(", "p", ".", "Context", ",", "p", ".", "APIClient", ",", "p", ".", "Ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "combined", ".", "Volumes", "=", "volumes", "\n", "}", "\n", "if", "p", ".", "WantStorage", "{", "storageInstances", ",", "err", ":=", "generateListStorageOutput", "(", "p", ".", "Context", ",", "p", ".", "APIClient", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "combined", ".", "StorageInstances", "=", "storageInstances", "\n", "}", "\n", "return", "combined", ",", "nil", "\n", "}" ]

[ "GetCombinedStorageInfo", "returns", "a", "list", "of", "StorageInstances", "Filesystems", "and", "Volumes", "for", "juju", "cmdline", "display", "purposes" ]

[ "func", "generateListStorageOutput", "(", "ctx", "*", "cmd", ".", "Context", ",", "api", "StorageListAPI", ")", "(", "map", "[", "string", "]", "StorageInfo", ",", "error", ")", "{", "results", ",", "err", ":=", "api", ".", "ListStorageDetails", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "results", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "formatStorageDetails", "(", "results", ")", "\n", "}" ]

[ "generateListStorageOutput", "returns", "a", "map", "of", "storage", "details" ]

[ "func", "(", "c", "*", "CombinedStorage", ")", "Empty", "(", ")", "bool", "{", "return", "len", "(", "c", ".", "StorageInstances", ")", "==", "0", "&&", "len", "(", "c", ".", "Filesystems", ")", "==", "0", "&&", "len", "(", "c", ".", "Volumes", ")", "==", "0", "\n", "}" ]

[ "Empty", "checks", "if", "CombinedStorage", "is", "empty", "." ]

[ "func", "formatListTabularOne", "(", "writer", "io", ".", "Writer", ",", "value", "interface", "{", "}", ")", "error", "{", "return", "formatListTabular", "(", "writer", ",", "value", ",", "false", ")", "\n", "}" ]

[ "formatListTabularOne", "writes", "a", "tabular", "summary", "of", "storage", "instances", "or", "filesystems", "or", "volumes", "." ]

[ "func", "FormatListTabularAll", "(", "writer", "io", ".", "Writer", ",", "value", "interface", "{", "}", ")", "error", "{", "return", "formatListTabular", "(", "writer", ",", "value", ",", "true", ")", "\n", "}" ]

[ "FormatListTabularAll", "writes", "a", "tabular", "summary", "of", "storage", "instances", "filesystems", "and", "volumes", "." ]

[ "func", "Manifold", "(", "config", "ManifoldConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "AgentName", ",", "config", ".", "APICallerName", ",", "}", ",", "Start", ":", "func", "(", "context", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "var", "agent", "agent", ".", "Agent", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "AgentName", ",", "&", "agent", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "apiCaller", "base", ".", "APICaller", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "APICallerName", ",", "&", "apiCaller", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "config", ".", "Clock", "==", "nil", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "MachineLock", "==", "nil", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "newWorker", "(", "agent", ",", "apiCaller", ",", "config", ".", "MachineLock", ",", "config", ".", "Clock", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "Manifold", "returns", "a", "dependency", "manifold", "that", "runs", "a", "reboot", "worker", "using", "the", "resource", "names", "defined", "in", "the", "supplied", "config", "." ]

[ "func", "ApplicationInstances", "(", "st", "*", "State", ",", "application", "string", ")", "(", "[", "]", "instance", ".", "Id", ",", "error", ")", "{", "units", ",", "err", ":=", "allUnits", "(", "st", ",", "application", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "instanceIds", ":=", "make", "(", "[", "]", "instance", ".", "Id", ",", "0", ",", "len", "(", "units", ")", ")", "\n", "for", "_", ",", "unit", ":=", "range", "units", "{", "machineId", ",", "err", ":=", "unit", ".", "AssignedMachineId", "(", ")", "\n", "if", "errors", ".", "IsNotAssigned", "(", "err", ")", "{", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "machine", ",", "err", ":=", "st", ".", "Machine", "(", "machineId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "instanceId", ",", "err", ":=", "machine", ".", "InstanceId", "(", ")", "\n", "if", "err", "==", "nil", "{", "instanceIds", "=", "append", "(", "instanceIds", ",", "instanceId", ")", "\n", "}", "else", "if", "errors", ".", "IsNotProvisioned", "(", "err", ")", "{", "continue", "\n", "}", "else", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "instanceIds", ",", "nil", "\n", "}" ]

[ "ApplicationInstances", "returns", "the", "instance", "IDs", "of", "provisioned", "machines", "that", "are", "assigned", "units", "of", "the", "specified", "application", "." ]

[ "func", "ApplicationMachines", "(", "st", "*", "State", ",", "application", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "machines", ",", "err", ":=", "st", ".", "AllMachines", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "applicationName", ":=", "unitAppName", "(", "application", ")", "\n", "var", "machineIds", "[", "]", "string", "\n", "for", "_", ",", "machine", ":=", "range", "machines", "{", "principalSet", ":=", "set", ".", "NewStrings", "(", ")", "\n", "for", "_", ",", "principal", ":=", "range", "machine", ".", "Principals", "(", ")", "{", "principalSet", ".", "Add", "(", "unitAppName", "(", "principal", ")", ")", "\n", "}", "\n", "if", "principalSet", ".", "Contains", "(", "applicationName", ")", "{", "machineIds", "=", "append", "(", "machineIds", ",", "machine", ".", "Id", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "machineIds", ",", "nil", "\n", "}" ]

[ "ApplicationMachines", "returns", "the", "machine", "IDs", "of", "machines", "which", "have", "the", "specified", "application", "listed", "as", "a", "principal", "." ]

[ "func", "NewAddressOnSpace", "(", "spaceName", "string", ",", "value", "string", ")", "Address", "{", "addr", ":=", "NewAddress", "(", "value", ")", "\n", "addr", ".", "SpaceName", "=", "SpaceName", "(", "spaceName", ")", "\n", "return", "addr", "\n", "}" ]

[ "NewAddressOnSpace", "creates", "a", "new", "Address", "deriving", "its", "type", "and", "scope", "from", "the", "value", "and", "associating", "it", "with", "the", "given", "spaceName", "." ]

[ "func", "NewAddresses", "(", "inAddresses", "...", "string", ")", "(", "outAddresses", "[", "]", "Address", ")", "{", "outAddresses", "=", "make", "(", "[", "]", "Address", ",", "len", "(", "inAddresses", ")", ")", "\n", "for", "i", ",", "address", ":=", "range", "inAddresses", "{", "outAddresses", "[", "i", "]", "=", "NewAddress", "(", "address", ")", "\n", "}", "\n", "return", "outAddresses", "\n", "}" ]

[ "NewAddresses", "is", "a", "convenience", "function", "to", "create", "addresses", "from", "a", "variable", "number", "of", "string", "arguments", "." ]

[ "func", "NewAddressesOnSpace", "(", "spaceName", "string", ",", "inAddresses", "...", "string", ")", "(", "outAddresses", "[", "]", "Address", ")", "{", "outAddresses", "=", "make", "(", "[", "]", "Address", ",", "len", "(", "inAddresses", ")", ")", "\n", "for", "i", ",", "address", ":=", "range", "inAddresses", "{", "outAddresses", "[", "i", "]", "=", "NewAddressOnSpace", "(", "spaceName", ",", "address", ")", "\n", "}", "\n", "return", "outAddresses", "\n", "}" ]

[ "NewAddressesOnSpace", "is", "a", "convenience", "function", "to", "create", "addresses", "on", "the", "same", "space", "from", "a", "a", "variable", "number", "of", "string", "arguments", "." ]

[ "func", "DeriveAddressType", "(", "value", "string", ")", "AddressType", "{", "ip", ":=", "net", ".", "ParseIP", "(", "value", ")", "\n", "switch", "{", "case", "ip", "==", "nil", ":", "// TODO(gz): Check value is a valid hostname", "return", "HostName", "\n", "case", "ip", ".", "To4", "(", ")", "!=", "nil", ":", "return", "IPv4Address", "\n", "case", "ip", ".", "To16", "(", ")", "!=", "nil", ":", "return", "IPv6Address", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "DeriveAddressType", "attempts", "to", "detect", "the", "type", "of", "address", "given", "." ]

[ "func", "deriveScope", "(", "addr", "Address", ")", "Scope", "{", "if", "addr", ".", "Type", "==", "HostName", "{", "return", "addr", ".", "Scope", "\n", "}", "\n", "ip", ":=", "net", ".", "ParseIP", "(", "addr", ".", "Value", ")", "\n", "if", "ip", "==", "nil", "{", "return", "addr", ".", "Scope", "\n", "}", "\n", "if", "ip", ".", "IsLoopback", "(", ")", "{", "return", "ScopeMachineLocal", "\n", "}", "\n", "if", "isIPv4PrivateNetworkAddress", "(", "addr", ".", "Type", ",", "ip", ")", "||", "isIPv6UniqueLocalAddress", "(", "addr", ".", "Type", ",", "ip", ")", "{", "return", "ScopeCloudLocal", "\n", "}", "\n", "if", "isIPv4ReservedEAddress", "(", "addr", ".", "Type", ",", "ip", ")", "{", "return", "ScopeFanLocal", "\n", "}", "\n\n", "if", "ip", ".", "IsLinkLocalMulticast", "(", ")", "||", "ip", ".", "IsLinkLocalUnicast", "(", ")", "||", "ip", ".", "IsInterfaceLocalMulticast", "(", ")", "{", "return", "ScopeLinkLocal", "\n", "}", "\n", "if", "ip", ".", "IsGlobalUnicast", "(", ")", "{", "return", "ScopePublic", "\n", "}", "\n", "return", "addr", ".", "Scope", "\n", "}" ]

[ "deriveScope", "attempts", "to", "derive", "the", "network", "scope", "from", "an", "address", "s", "type", "and", "value", "returning", "the", "original", "network", "scope", "if", "no", "deduction", "can", "be", "made", "." ]

[ "func", "ExactScopeMatch", "(", "addr", "Address", ",", "addrScopes", "...", "Scope", ")", "bool", "{", "for", "_", ",", "scope", ":=", "range", "addrScopes", "{", "if", "addr", ".", "Scope", "==", "scope", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "ExactScopeMatch", "checks", "if", "an", "address", "exactly", "matches", "any", "of", "the", "specified", "scopes", "." ]

[ "func", "SelectAddressesBySpaceNames", "(", "addresses", "[", "]", "Address", ",", "spaceNames", "...", "SpaceName", ")", "(", "[", "]", "Address", ",", "bool", ")", "{", "if", "len", "(", "spaceNames", ")", "==", "0", "{", "logger", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "addresses", ",", "false", "\n", "}", "\n\n", "var", "selectedAddresses", "[", "]", "Address", "\n", "for", "_", ",", "addr", ":=", "range", "addresses", "{", "if", "spaceNameList", "(", "spaceNames", ")", ".", "IndexOf", "(", "addr", ".", "SpaceName", ")", ">=", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "addr", ".", "Value", ",", "addr", ".", "SpaceName", ")", "\n", "selectedAddresses", "=", "append", "(", "selectedAddresses", ",", "addr", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "selectedAddresses", ")", ">", "0", "{", "return", "selectedAddresses", ",", "true", "\n", "}", "\n\n", "logger", ".", "Errorf", "(", "\"", "\"", ",", "spaceNames", ")", "\n", "return", "addresses", ",", "false", "\n", "}" ]

[ "SelectAddressesBySpaceNames", "filters", "the", "input", "slice", "of", "Addresses", "down", "to", "those", "in", "the", "input", "space", "names", "." ]

[ "func", "SelectHostPortsBySpaceNames", "(", "hps", "[", "]", "HostPort", ",", "spaceNames", "...", "SpaceName", ")", "(", "[", "]", "HostPort", ",", "bool", ")", "{", "if", "len", "(", "spaceNames", ")", "==", "0", "{", "logger", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "hps", ",", "false", "\n", "}", "\n\n", "var", "selectedHostPorts", "[", "]", "HostPort", "\n", "for", "_", ",", "hp", ":=", "range", "hps", "{", "if", "spaceNameList", "(", "spaceNames", ")", ".", "IndexOf", "(", "hp", ".", "SpaceName", ")", ">=", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "hp", ".", "Value", ",", "hp", ".", "SpaceName", ")", "\n", "selectedHostPorts", "=", "append", "(", "selectedHostPorts", ",", "hp", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "selectedHostPorts", ")", ">", "0", "{", "return", "selectedHostPorts", ",", "true", "\n", "}", "\n\n", "logger", ".", "Errorf", "(", "\"", "\"", ",", "spaceNames", ")", "\n", "return", "hps", ",", "false", "\n", "}" ]

[ "SelectHostPortsBySpaceNames", "filters", "the", "input", "slice", "of", "HostPorts", "down", "to", "those", "in", "the", "input", "space", "names", "." ]

[ "func", "SelectPublicHostPort", "(", "hps", "[", "]", "HostPort", ")", "string", "{", "index", ":=", "bestAddressIndex", "(", "len", "(", "hps", ")", ",", "func", "(", "i", "int", ")", "Address", "{", "return", "hps", "[", "i", "]", ".", "Address", "\n", "}", ",", "publicMatch", ")", "\n", "if", "index", "<", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "hps", "[", "index", "]", ".", "NetAddr", "(", ")", "\n", "}" ]

[ "SelectPublicHostPort", "picks", "one", "HostPort", "from", "a", "slice", "that", "would", "be", "appropriate", "to", "display", "as", "a", "publicly", "accessible", "endpoint", ".", "If", "there", "are", "no", "suitable", "candidates", "the", "empty", "string", "is", "returned", "." ]

[ "func", "SelectInternalAddresses", "(", "addresses", "[", "]", "Address", ",", "machineLocal", "bool", ")", "[", "]", "Address", "{", "indexes", ":=", "bestAddressIndexes", "(", "len", "(", "addresses", ")", ",", "func", "(", "i", "int", ")", "Address", "{", "return", "addresses", "[", "i", "]", "\n", "}", ",", "internalAddressMatcher", "(", "machineLocal", ")", ")", "\n", "if", "len", "(", "indexes", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "out", ":=", "make", "(", "[", "]", "Address", ",", "0", ",", "len", "(", "indexes", ")", ")", "\n", "for", "_", ",", "index", ":=", "range", "indexes", "{", "out", "=", "append", "(", "out", ",", "addresses", "[", "index", "]", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "SelectInternalAddresses", "picks", "the", "best", "addresses", "from", "a", "slice", "that", "can", "be", "used", "as", "an", "endpoint", "for", "juju", "internal", "communication", ".", "I", "nil", "slice", "is", "returned", "if", "there", "are", "no", "suitable", "addresses", "identified", "." ]

[ "func", "SelectInternalHostPort", "(", "hps", "[", "]", "HostPort", ",", "machineLocal", "bool", ")", "string", "{", "index", ":=", "bestAddressIndex", "(", "len", "(", "hps", ")", ",", "func", "(", "i", "int", ")", "Address", "{", "return", "hps", "[", "i", "]", ".", "Address", "\n", "}", ",", "internalAddressMatcher", "(", "machineLocal", ")", ")", "\n", "if", "index", "<", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "hps", "[", "index", "]", ".", "NetAddr", "(", ")", "\n", "}" ]

[ "SelectInternalHostPort", "picks", "one", "HostPort", "from", "a", "slice", "that", "can", "be", "used", "as", "an", "endpoint", "for", "juju", "internal", "communication", "and", "returns", "it", "in", "its", "NetAddr", "form", ".", "If", "there", "are", "no", "suitable", "addresses", "the", "empty", "string", "is", "returned", "." ]

[ "func", "SelectInternalHostPorts", "(", "hps", "[", "]", "HostPort", ",", "machineLocal", "bool", ")", "[", "]", "string", "{", "indexes", ":=", "bestAddressIndexes", "(", "len", "(", "hps", ")", ",", "func", "(", "i", "int", ")", "Address", "{", "return", "hps", "[", "i", "]", ".", "Address", "\n", "}", ",", "internalAddressMatcher", "(", "machineLocal", ")", ")", "\n\n", "out", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "indexes", ")", ")", "\n", "for", "_", ",", "index", ":=", "range", "indexes", "{", "out", "=", "append", "(", "out", ",", "hps", "[", "index", "]", ".", "NetAddr", "(", ")", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "SelectInternalHostPorts", "picks", "the", "best", "matching", "HostPorts", "from", "a", "slice", "that", "can", "be", "used", "as", "an", "endpoint", "for", "juju", "internal", "communication", "and", "returns", "them", "in", "NetAddr", "form", ".", "If", "there", "are", "no", "suitable", "addresses", "an", "empty", "slice", "is", "returned", "." ]

[ "func", "DecimalToIPv4", "(", "addr", "uint32", ")", "net", ".", "IP", "{", "bytes", ":=", "make", "(", "[", "]", "byte", ",", "4", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "bytes", ",", "addr", ")", "\n", "return", "net", ".", "IP", "(", "bytes", ")", "\n", "}" ]

[ "DecimalToIPv4", "converts", "a", "decimal", "to", "the", "dotted", "quad", "IP", "address", "format", "." ]

[ "func", "IPv4ToDecimal", "(", "ipv4Addr", "net", ".", "IP", ")", "(", "uint32", ",", "error", ")", "{", "ip", ":=", "ipv4Addr", ".", "To4", "(", ")", "\n", "if", "ip", "==", "nil", "{", "return", "0", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "ipv4Addr", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "binary", ".", "BigEndian", ".", "Uint32", "(", "[", "]", "byte", "(", "ip", ")", ")", ",", "nil", "\n", "}" ]

[ "IPv4ToDecimal", "converts", "a", "dotted", "quad", "IP", "address", "to", "its", "decimal", "equivalent", "." ]

[ "func", "machineBlockDevicesChanged", "(", "ctx", "*", "context", ")", "error", "{", "volumeTags", ":=", "make", "(", "[", "]", "names", ".", "VolumeTag", ",", "0", ",", "len", "(", "ctx", ".", "incompleteFilesystemParams", ")", ")", "\n", "// We must query volumes for both incomplete filesystems", "// and incomplete filesystem attachments, because even", "// though a filesystem attachment cannot exist without a", "// filesystem, the filesystem may be created and attached", "// in different sessions, and there is no guarantee that", "// the block device will remain attached to the machine", "// in between.", "for", "_", ",", "params", ":=", "range", "ctx", ".", "incompleteFilesystemParams", "{", "if", "params", ".", "Volume", "==", "(", "names", ".", "VolumeTag", "{", "}", ")", "{", "// Filesystem is not volume-backed.", "continue", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "ctx", ".", "volumeBlockDevices", "[", "params", ".", "Volume", "]", ";", "ok", "{", "// Backing-volume's block device is already attached.", "continue", "\n", "}", "\n", "volumeTags", "=", "append", "(", "volumeTags", ",", "params", ".", "Volume", ")", "\n", "}", "\n", "for", "_", ",", "params", ":=", "range", "ctx", ".", "incompleteFilesystemAttachmentParams", "{", "filesystem", ",", "ok", ":=", "ctx", ".", "filesystems", "[", "params", ".", "Filesystem", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "if", "filesystem", ".", "Volume", "==", "(", "names", ".", "VolumeTag", "{", "}", ")", "{", "// Filesystem is not volume-backed.", "continue", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "ctx", ".", "volumeBlockDevices", "[", "filesystem", ".", "Volume", "]", ";", "ok", "{", "// Backing-volume's block device is already attached.", "continue", "\n", "}", "\n", "var", "found", "bool", "\n", "for", "_", ",", "tag", ":=", "range", "volumeTags", "{", "if", "filesystem", ".", "Volume", "==", "tag", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "volumeTags", "=", "append", "(", "volumeTags", ",", "filesystem", ".", "Volume", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "volumeTags", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "refreshVolumeBlockDevices", "(", "ctx", ",", "volumeTags", ")", "\n", "}" ]

[ "machineBlockDevicesChanged", "is", "called", "when", "the", "block", "devices", "of", "the", "scoped", "machine", "have", "been", "seen", "to", "have", "changed", ".", "This", "triggers", "a", "refresh", "of", "all", "block", "devices", "for", "attached", "volumes", "backing", "pending", "filesystems", "." ]

[ "func", "processPendingVolumeBlockDevices", "(", "ctx", "*", "context", ")", "error", "{", "if", "len", "(", "ctx", ".", "pendingVolumeBlockDevices", ")", "==", "0", "{", "logger", ".", "Tracef", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "volumeTags", ":=", "make", "(", "[", "]", "names", ".", "VolumeTag", ",", "len", "(", "ctx", ".", "pendingVolumeBlockDevices", ")", ")", "\n", "for", "i", ",", "tag", ":=", "range", "ctx", ".", "pendingVolumeBlockDevices", ".", "SortedValues", "(", ")", "{", "volumeTags", "[", "i", "]", "=", "tag", ".", "(", "names", ".", "VolumeTag", ")", "\n", "}", "\n", "// Clear out the pending set, so we don't force-refresh again.", "ctx", ".", "pendingVolumeBlockDevices", "=", "names", ".", "NewSet", "(", ")", "\n", "return", "refreshVolumeBlockDevices", "(", "ctx", ",", "volumeTags", ")", "\n", "}" ]

[ "processPendingVolumeBlockDevices", "is", "called", "before", "waiting", "for", "any", "events", "to", "force", "a", "block", "-", "device", "query", "for", "any", "volumes", "for", "which", "we", "have", "not", "previously", "observed", "block", "devices", "." ]

[ "func", "refreshVolumeBlockDevices", "(", "ctx", "*", "context", ",", "volumeTags", "[", "]", "names", ".", "VolumeTag", ")", "error", "{", "machineTag", ",", "ok", ":=", "ctx", ".", "config", ".", "Scope", ".", "(", "names", ".", "MachineTag", ")", "\n", "if", "!", "ok", "{", "// This function should only be called by machine-scoped", "// storage provisioners.", "logger", ".", "Warningf", "(", "\"", "\"", ",", "ctx", ".", "config", ".", "Scope", ")", "\n", "return", "nil", "\n", "}", "\n", "ids", ":=", "make", "(", "[", "]", "params", ".", "MachineStorageId", ",", "len", "(", "volumeTags", ")", ")", "\n", "for", "i", ",", "volumeTag", ":=", "range", "volumeTags", "{", "ids", "[", "i", "]", "=", "params", ".", "MachineStorageId", "{", "MachineTag", ":", "machineTag", ".", "String", "(", ")", ",", "AttachmentTag", ":", "volumeTag", ".", "String", "(", ")", ",", "}", "\n", "}", "\n", "results", ",", "err", ":=", "ctx", ".", "config", ".", "Volumes", ".", "VolumeBlockDevices", "(", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "i", ",", "result", ":=", "range", "results", "{", "if", "result", ".", "Error", "==", "nil", "{", "ctx", ".", "volumeBlockDevices", "[", "volumeTags", "[", "i", "]", "]", "=", "result", ".", "Result", "\n", "for", "_", ",", "params", ":=", "range", "ctx", ".", "incompleteFilesystemParams", "{", "if", "params", ".", "Volume", "==", "volumeTags", "[", "i", "]", "{", "updatePendingFilesystem", "(", "ctx", ",", "params", ")", "\n", "}", "\n", "}", "\n", "for", "id", ",", "params", ":=", "range", "ctx", ".", "incompleteFilesystemAttachmentParams", "{", "filesystem", ",", "ok", ":=", "ctx", ".", "filesystems", "[", "params", ".", "Filesystem", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "if", "filesystem", ".", "Volume", "==", "volumeTags", "[", "i", "]", "{", "updatePendingFilesystemAttachment", "(", "ctx", ",", "id", ",", "params", ")", "\n", "}", "\n", "}", "\n", "}", "else", "if", "params", ".", "IsCodeNotProvisioned", "(", "result", ".", "Error", ")", "||", "params", ".", "IsCodeNotFound", "(", "result", ".", "Error", ")", "{", "// Either the volume (attachment) isn't provisioned,", "// or the corresponding block device is not yet known.", "//", "// Neither of these errors is fatal; we just wait for", "// the block device watcher to notify us again.", "}", "else", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "ids", "[", "i", "]", ",", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "refreshVolumeBlockDevices", "refreshes", "the", "block", "devices", "for", "the", "specified", "volumes", "." ]

[ "func", "NewLayeredStorage", "(", "s", "...", "Storage", ")", "(", "Storage", ",", "error", ")", "{", "if", "len", "(", "s", ")", "<=", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "layeredStorage", "(", "s", ")", ",", "nil", "\n", "}" ]

[ "NewLayeredStorage", "wraps", "multiple", "Storages", "such", "all", "of", "their", "metadata", "can", "be", "listed", "and", "fetched", ".", "The", "later", "entries", "in", "the", "list", "have", "lower", "precedence", "than", "the", "earlier", "ones", ".", "The", "first", "entry", "in", "the", "list", "is", "always", "used", "for", "mutating", "operations", "." ]

[ "func", "(", "s", "layeredStorage", ")", "Add", "(", "r", "io", ".", "Reader", ",", "m", "Metadata", ")", "error", "{", "return", "s", "[", "0", "]", ".", "Add", "(", "r", ",", "m", ")", "\n", "}" ]

[ "Add", "implements", "Storage", ".", "Add", ".", "This", "method", "operates", "on", "the", "first", "Storage", "passed", "to", "NewLayeredStorage", "." ]

[ "func", "(", "s", "layeredStorage", ")", "Open", "(", "v", "string", ")", "(", "Metadata", ",", "io", ".", "ReadCloser", ",", "error", ")", "{", "var", "m", "Metadata", "\n", "var", "rc", "io", ".", "ReadCloser", "\n", "var", "err", "error", "\n", "for", "_", ",", "s", ":=", "range", "s", "{", "m", ",", "rc", ",", "err", "=", "s", ".", "Open", "(", "v", ")", "\n", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "break", "\n", "}", "\n", "}", "\n", "return", "m", ",", "rc", ",", "err", "\n", "}" ]

[ "Open", "implements", "Storage", ".", "Open", ".", "This", "method", "calls", "Open", "for", "each", "Storage", "passed", "to", "NewLayeredStorage", "in", "the", "order", "given", "and", "returns", "the", "first", "result", "where", "the", "error", "does", "not", "satisfy", "errors", ".", "IsNotFound", "." ]

[ "func", "(", "s", "layeredStorage", ")", "Metadata", "(", "v", "string", ")", "(", "Metadata", ",", "error", ")", "{", "var", "m", "Metadata", "\n", "var", "err", "error", "\n", "for", "_", ",", "s", ":=", "range", "s", "{", "m", ",", "err", "=", "s", ".", "Metadata", "(", "v", ")", "\n", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "break", "\n", "}", "\n", "}", "\n", "return", "m", ",", "err", "\n", "}" ]

[ "Metadata", "implements", "Storage", ".", "Metadata", ".", "This", "method", "calls", "Metadata", "for", "each", "Storage", "passed", "to", "NewLayeredStorage", "in", "the", "order", "given", "and", "returns", "the", "first", "result", "where", "the", "error", "does", "not", "satisfy", "errors", ".", "IsNotFound", "." ]

[ "func", "(", "s", "layeredStorage", ")", "AllMetadata", "(", ")", "(", "[", "]", "Metadata", ",", "error", ")", "{", "seen", ":=", "set", ".", "NewStrings", "(", ")", "\n", "var", "all", "[", "]", "Metadata", "\n", "for", "_", ",", "s", ":=", "range", "s", "{", "sm", ",", "err", ":=", "s", ".", "AllMetadata", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "m", ":=", "range", "sm", "{", "if", "seen", ".", "Contains", "(", "m", ".", "Version", ")", "{", "continue", "\n", "}", "\n", "all", "=", "append", "(", "all", ",", "m", ")", "\n", "seen", ".", "Add", "(", "m", ".", "Version", ")", "\n", "}", "\n", "}", "\n", "return", "all", ",", "nil", "\n", "}" ]

[ "AllMetadata", "implements", "Storage", ".", "AllMetadata", ".", "This", "method", "calls", "AllMetadata", "for", "each", "Storage", "passed", "to", "NewLayeredStorage", "in", "the", "order", "given", "and", "accumulates", "the", "results", ".", "Any", "results", "from", "a", "Storage", "earlier", "in", "the", "list", "will", "take", "precedence", "over", "any", "others", "with", "the", "same", "version", "." ]

[ "func", "(", "staged", "StagedResource", ")", "Unstage", "(", ")", "error", "{", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "if", "attempt", ">", "0", "{", "// The op has no assert so we should not get here.", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ops", ":=", "newRemoveStagedResourceOps", "(", "staged", ".", "id", ")", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "if", "err", ":=", "staged", ".", "base", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Unstage", "ensures", "that", "the", "resource", "is", "removed", "from", "the", "staging", "area", ".", "If", "it", "isn", "t", "in", "the", "staging", "area", "then", "this", "is", "a", "noop", "." ]

[ "func", "(", "staged", "StagedResource", ")", "Activate", "(", ")", "error", "{", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "// This is an \"upsert\".", "var", "ops", "[", "]", "txn", ".", "Op", "\n", "switch", "attempt", "{", "case", "0", ":", "ops", "=", "newInsertResourceOps", "(", "staged", ".", "stored", ")", "\n", "case", "1", ":", "ops", "=", "newUpdateResourceOps", "(", "staged", ".", "stored", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "staged", ".", "stored", ".", "PendingID", "==", "\"", "\"", "{", "// Only non-pending resources must have an existing application.", "ops", "=", "append", "(", "ops", ",", "staged", ".", "base", ".", "ApplicationExistsOps", "(", "staged", ".", "stored", ".", "ApplicationID", ")", "...", ")", "\n", "}", "\n", "// No matter what, we always remove any staging.", "ops", "=", "append", "(", "ops", ",", "newRemoveStagedResourceOps", "(", "staged", ".", "id", ")", "...", ")", "\n\n", "// If we are changing the bytes for a resource, we increment the", "// CharmModifiedVersion on the application, since resources are integral to", "// the high level \"version\" of the charm.", "if", "staged", ".", "stored", ".", "PendingID", "==", "\"", "\"", "{", "hasNewBytes", ",", "err", ":=", "staged", ".", "hasNewBytes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "errors", ".", "Details", "(", "err", ")", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "hasNewBytes", "{", "incOps", ":=", "staged", ".", "base", ".", "IncCharmModifiedVersionOps", "(", "staged", ".", "stored", ".", "ApplicationID", ")", "\n", "ops", "=", "append", "(", "ops", ",", "incOps", "...", ")", "\n", "}", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "if", "err", ":=", "staged", ".", "base", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Activate", "makes", "the", "staged", "resource", "the", "active", "resource", "." ]

[ "func", "(", "a", "*", "action", ")", "Id", "(", ")", "string", "{", "return", "a", ".", "st", ".", "localID", "(", "a", ".", "doc", ".", "DocId", ")", "\n", "}" ]

[ "Id", "returns", "the", "local", "id", "of", "the", "Action", "." ]

[ "func", "(", "a", "*", "action", ")", "Results", "(", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "string", ")", "{", "return", "a", ".", "doc", ".", "Results", ",", "a", ".", "doc", ".", "Message", "\n", "}" ]

[ "Results", "returns", "the", "structured", "output", "of", "the", "action", "and", "any", "error", "." ]

[ "func", "(", "a", "*", "action", ")", "Begin", "(", ")", "(", "Action", ",", "error", ")", "{", "m", ",", "err", ":=", "a", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "err", "=", "m", ".", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "actionsC", ",", "Id", ":", "a", ".", "doc", ".", "DocId", ",", "Assert", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "ActionPending", "}", "}", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "ActionRunning", "}", ",", "{", "\"", "\"", ",", "a", ".", "st", ".", "nowToTheSecond", "(", ")", "}", ",", "}", "}", "}", ",", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "m", ".", "Action", "(", "a", ".", "Id", "(", ")", ")", "\n", "}" ]

[ "Begin", "marks", "an", "action", "as", "running", "and", "logs", "the", "time", "it", "was", "started", ".", "It", "asserts", "that", "the", "action", "is", "currently", "pending", "." ]

[ "func", "(", "a", "*", "action", ")", "Finish", "(", "results", "ActionResults", ")", "(", "Action", ",", "error", ")", "{", "return", "a", ".", "removeAndLog", "(", "results", ".", "Status", ",", "results", ".", "Results", ",", "results", ".", "Message", ")", "\n", "}" ]

[ "Finish", "removes", "action", "from", "the", "pending", "queue", "and", "captures", "the", "output", "and", "end", "state", "of", "the", "action", "." ]

[ "func", "(", "a", "*", "action", ")", "removeAndLog", "(", "finalStatus", "ActionStatus", ",", "results", "map", "[", "string", "]", "interface", "{", "}", ",", "message", "string", ")", "(", "Action", ",", "error", ")", "{", "m", ",", "err", ":=", "a", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "m", ".", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "actionsC", ",", "Id", ":", "a", ".", "doc", ".", "DocId", ",", "Assert", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "ActionCompleted", ",", "ActionCancelled", ",", "ActionFailed", ",", "}", "}", "}", "}", "}", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "finalStatus", "}", ",", "{", "\"", "\"", ",", "message", "}", ",", "{", "\"", "\"", ",", "results", "}", ",", "{", "\"", "\"", ",", "a", ".", "st", ".", "nowToTheSecond", "(", ")", "}", ",", "}", "}", "}", ",", "}", ",", "{", "C", ":", "actionNotificationsC", ",", "Id", ":", "m", ".", "st", ".", "docID", "(", "ensureActionMarker", "(", "a", ".", "Receiver", "(", ")", ")", "+", "a", ".", "Id", "(", ")", ")", ",", "Remove", ":", "true", ",", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "m", ".", "Action", "(", "a", ".", "Id", "(", ")", ")", "\n", "}" ]

[ "removeAndLog", "takes", "the", "action", "off", "of", "the", "pending", "queue", "and", "creates", "an", "actionresult", "to", "capture", "the", "outcome", "of", "the", "action", ".", "It", "asserts", "that", "the", "action", "is", "not", "already", "completed", "." ]

[ "func", "newAction", "(", "st", "*", "State", ",", "adoc", "actionDoc", ")", "Action", "{", "return", "&", "action", "{", "st", ":", "st", ",", "doc", ":", "adoc", ",", "}", "\n", "}" ]

[ "newAction", "builds", "an", "Action", "for", "the", "given", "State", "and", "actionDoc", "." ]

[ "func", "newActionDoc", "(", "mb", "modelBackend", ",", "receiverTag", "names", ".", "Tag", ",", "actionName", "string", ",", "parameters", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "actionDoc", ",", "actionNotificationDoc", ",", "error", ")", "{", "prefix", ":=", "ensureActionMarker", "(", "receiverTag", ".", "Id", "(", ")", ")", "\n", "actionId", ",", "err", ":=", "NewUUID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "actionDoc", "{", "}", ",", "actionNotificationDoc", "{", "}", ",", "err", "\n", "}", "\n", "actionLogger", ".", "Debugf", "(", "\"", "\"", ",", "actionName", ",", "receiverTag", ",", "actionId", ")", "\n", "modelUUID", ":=", "mb", ".", "modelUUID", "(", ")", "\n", "return", "actionDoc", "{", "DocId", ":", "mb", ".", "docID", "(", "actionId", ".", "String", "(", ")", ")", ",", "ModelUUID", ":", "modelUUID", ",", "Receiver", ":", "receiverTag", ".", "Id", "(", ")", ",", "Name", ":", "actionName", ",", "Parameters", ":", "parameters", ",", "Enqueued", ":", "mb", ".", "nowToTheSecond", "(", ")", ",", "Status", ":", "ActionPending", ",", "}", ",", "actionNotificationDoc", "{", "DocId", ":", "mb", ".", "docID", "(", "prefix", "+", "actionId", ".", "String", "(", ")", ")", ",", "ModelUUID", ":", "modelUUID", ",", "Receiver", ":", "receiverTag", ".", "Id", "(", ")", ",", "ActionID", ":", "actionId", ".", "String", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "newActionDoc", "builds", "the", "actionDoc", "with", "the", "given", "name", "and", "parameters", "." ]

[ "func", "(", "m", "*", "Model", ")", "Action", "(", "id", "string", ")", "(", "Action", ",", "error", ")", "{", "actionLogger", ".", "Tracef", "(", "\"", "\"", ",", "id", ")", "\n", "st", ":=", "m", ".", "st", "\n", "actions", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "actionsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "doc", ":=", "actionDoc", "{", "}", "\n", "err", ":=", "actions", ".", "FindId", "(", "id", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "actionLogger", ".", "Tracef", "(", "\"", "\"", ",", "id", ",", "doc", ")", "\n", "return", "newAction", "(", "st", ",", "doc", ")", ",", "nil", "\n", "}" ]

[ "Action", "returns", "an", "Action", "by", "Id", "which", "is", "a", "UUID", "." ]

[ "func", "(", "m", "*", "Model", ")", "AllActions", "(", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "actionLogger", ".", "Tracef", "(", "\"", "\"", ")", "\n", "actions", ",", "closer", ":=", "m", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "actionsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "results", ":=", "[", "]", "Action", "{", "}", "\n", "docs", ":=", "[", "]", "actionDoc", "{", "}", "\n", "err", ":=", "actions", ".", "Find", "(", "nil", ")", ".", "All", "(", "&", "docs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "doc", ":=", "range", "docs", "{", "results", "=", "append", "(", "results", ",", "newAction", "(", "m", ".", "st", ",", "doc", ")", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "AllActions", "returns", "all", "Actions", "." ]

[ "func", "(", "m", "*", "Model", ")", "ActionByTag", "(", "tag", "names", ".", "ActionTag", ")", "(", "Action", ",", "error", ")", "{", "return", "m", ".", "Action", "(", "tag", ".", "Id", "(", ")", ")", "\n", "}" ]

[ "ActionByTag", "returns", "an", "Action", "given", "an", "ActionTag", "." ]

[ "func", "(", "m", "*", "Model", ")", "FindActionTagsByPrefix", "(", "prefix", "string", ")", "[", "]", "names", ".", "ActionTag", "{", "actionLogger", ".", "Tracef", "(", "\"", "\"", ",", "prefix", ")", "\n", "var", "results", "[", "]", "names", ".", "ActionTag", "\n", "var", "doc", "struct", "{", "Id", "string", "`bson:\"_id\"`", "\n", "}", "\n\n", "actions", ",", "closer", ":=", "m", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "actionsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "iter", ":=", "actions", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "\"", "\"", "+", "m", ".", "st", ".", "docID", "(", "prefix", ")", "}", "}", "}", "}", ")", ".", "Iter", "(", ")", "\n", "defer", "iter", ".", "Close", "(", ")", "\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "actionLogger", ".", "Tracef", "(", "\"", "\"", ",", "doc", ")", "\n", "localID", ":=", "m", ".", "st", ".", "localID", "(", "doc", ".", "Id", ")", "\n", "if", "names", ".", "IsValidAction", "(", "localID", ")", "{", "results", "=", "append", "(", "results", ",", "names", ".", "NewActionTag", "(", "localID", ")", ")", "\n", "}", "\n", "}", "\n", "actionLogger", ".", "Tracef", "(", "\"", "\"", ",", "prefix", ",", "results", ")", "\n", "return", "results", "\n", "}" ]

[ "FindActionTagsByPrefix", "finds", "Actions", "with", "ids", "that", "share", "the", "supplied", "prefix", "and", "returns", "a", "list", "of", "corresponding", "ActionTags", "." ]

[ "func", "(", "m", "*", "Model", ")", "FindActionsByName", "(", "name", "string", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "var", "results", "[", "]", "Action", "\n", "var", "doc", "actionDoc", "\n\n", "actions", ",", "closer", ":=", "m", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "actionsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "iter", ":=", "actions", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "name", "}", "}", ")", ".", "Iter", "(", ")", "\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "results", "=", "append", "(", "results", ",", "newAction", "(", "m", ".", "st", ",", "doc", ")", ")", "\n", "}", "\n", "return", "results", ",", "errors", ".", "Trace", "(", "iter", ".", "Close", "(", ")", ")", "\n", "}" ]

[ "FindActionsByName", "finds", "Actions", "with", "the", "given", "name", "." ]

[ "func", "(", "st", "*", "State", ")", "matchingActions", "(", "ar", "ActionReceiver", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "return", "st", ".", "matchingActionsByReceiverId", "(", "ar", ".", "Tag", "(", ")", ".", "Id", "(", ")", ")", "\n", "}" ]

[ "matchingActions", "finds", "actions", "that", "match", "ActionReceiver", "." ]

[ "func", "(", "st", "*", "State", ")", "matchingActionsByReceiverId", "(", "id", "string", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "var", "doc", "actionDoc", "\n", "var", "actions", "[", "]", "Action", "\n\n", "actionsCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "actionsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "iter", ":=", "actionsCollection", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "id", "}", "}", ")", ".", "Iter", "(", ")", "\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "actions", "=", "append", "(", "actions", ",", "newAction", "(", "st", ",", "doc", ")", ")", "\n", "}", "\n", "return", "actions", ",", "errors", ".", "Trace", "(", "iter", ".", "Close", "(", ")", ")", "\n", "}" ]

[ "matchingActionsByReceiverId", "finds", "actions", "that", "match", "ActionReceiver", "name", "." ]

[ "func", "(", "st", "*", "State", ")", "matchingActionsPending", "(", "ar", "ActionReceiver", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "completed", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "ActionPending", "}", "}", "\n", "return", "st", ".", "matchingActionsByReceiverAndStatus", "(", "ar", ".", "Tag", "(", ")", ",", "completed", ")", "\n", "}" ]

[ "matchingActionsPending", "finds", "actions", "that", "match", "ActionReceiver", "and", "that", "are", "pending", "." ]

[ "func", "(", "st", "*", "State", ")", "matchingActionsRunning", "(", "ar", "ActionReceiver", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "completed", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "ActionRunning", "}", "}", "\n", "return", "st", ".", "matchingActionsByReceiverAndStatus", "(", "ar", ".", "Tag", "(", ")", ",", "completed", ")", "\n", "}" ]

[ "matchingActionsRunning", "finds", "actions", "that", "match", "ActionReceiver", "and", "that", "are", "running", "." ]

[ "func", "(", "st", "*", "State", ")", "matchingActionsCompleted", "(", "ar", "ActionReceiver", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "completed", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "[", "]", "bson", ".", "D", "{", "{", "{", "\"", "\"", ",", "ActionCompleted", "}", "}", ",", "{", "{", "\"", "\"", ",", "ActionCancelled", "}", "}", ",", "{", "{", "\"", "\"", ",", "ActionFailed", "}", "}", ",", "}", "}", "}", "\n", "return", "st", ".", "matchingActionsByReceiverAndStatus", "(", "ar", ".", "Tag", "(", ")", ",", "completed", ")", "\n", "}" ]

[ "matchingActionsCompleted", "finds", "actions", "that", "match", "ActionReceiver", "and", "that", "are", "complete", "." ]

[ "func", "(", "st", "*", "State", ")", "matchingActionsByReceiverAndStatus", "(", "tag", "names", ".", "Tag", ",", "statusCondition", "bson", ".", "D", ")", "(", "[", "]", "Action", ",", "error", ")", "{", "var", "doc", "actionDoc", "\n", "var", "actions", "[", "]", "Action", "\n\n", "actionsCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "actionsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "sel", ":=", "append", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "tag", ".", "Id", "(", ")", "}", "}", ",", "statusCondition", "...", ")", "\n", "iter", ":=", "actionsCollection", ".", "Find", "(", "sel", ")", ".", "Iter", "(", ")", "\n\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "actions", "=", "append", "(", "actions", ",", "newAction", "(", "st", ",", "doc", ")", ")", "\n", "}", "\n", "return", "actions", ",", "errors", ".", "Trace", "(", "iter", ".", "Close", "(", ")", ")", "\n", "}" ]

[ "matchingActionsByReceiverAndStatus", "finds", "actionNotifications", "that", "match", "ActionReceiver", "." ]

[ "func", "(", "c", "*", "Client", ")", "CharmInfo", "(", "charmURL", "string", ")", "(", "*", "CharmInfo", ",", "error", ")", "{", "args", ":=", "params", ".", "CharmURL", "{", "URL", ":", "charmURL", "}", "\n", "var", "info", "params", ".", "CharmInfo", "\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "info", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "meta", ",", "err", ":=", "convertCharmMeta", "(", "info", ".", "Meta", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "result", ":=", "&", "CharmInfo", "{", "Revision", ":", "info", ".", "Revision", ",", "URL", ":", "info", ".", "URL", ",", "Config", ":", "convertCharmConfig", "(", "info", ".", "Config", ")", ",", "Meta", ":", "meta", ",", "Actions", ":", "convertCharmActions", "(", "info", ".", "Actions", ")", ",", "Metrics", ":", "convertCharmMetrics", "(", "info", ".", "Metrics", ")", ",", "LXDProfile", ":", "convertCharmLXDProfile", "(", "info", ".", "LXDProfile", ")", ",", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "CharmInfo", "returns", "information", "about", "the", "requested", "charm", "." ]

[ "func", "NewAddCloudCommand", "(", "cloudMetadataStore", "CloudMetadataStore", ")", "cmd", ".", "Command", "{", "cloudCallCtx", ":=", "context", ".", "NewCloudCallContext", "(", ")", "\n", "store", ":=", "jujuclient", ".", "NewFileClientStore", "(", ")", "\n", "c", ":=", "&", "AddCloudCommand", "{", "OptionalControllerCommand", ":", "modelcmd", ".", "OptionalControllerCommand", "{", "Store", ":", "store", "}", ",", "cloudMetadataStore", ":", "cloudMetadataStore", ",", "CloudCallCtx", ":", "cloudCallCtx", ",", "// Ping is provider.Ping except in tests where we don't actually want to", "// require a valid cloud.", "Ping", ":", "func", "(", "p", "environs", ".", "EnvironProvider", ",", "endpoint", "string", ")", "error", "{", "return", "p", ".", "Ping", "(", "cloudCallCtx", ",", "endpoint", ")", "\n", "}", ",", "store", ":", "store", ",", "}", "\n", "c", ".", "addCloudAPIFunc", "=", "c", ".", "cloudAPI", "\n", "return", "modelcmd", ".", "WrapBase", "(", "c", ")", "\n", "}" ]

[ "NewAddCloudCommand", "returns", "a", "command", "to", "add", "cloud", "information", "." ]

[ "func", "(", "c", "*", "AddCloudCommand", ")", "Run", "(", "ctxt", "*", "cmd", ".", "Context", ")", "error", "{", "if", "c", ".", "CloudFile", "==", "\"", "\"", "&&", "c", ".", "controllerName", "==", "\"", "\"", "{", "return", "c", ".", "runInteractive", "(", "ctxt", ")", "\n", "}", "\n\n", "var", "newCloud", "*", "jujucloud", ".", "Cloud", "\n", "var", "err", "error", "\n", "if", "c", ".", "CloudFile", "!=", "\"", "\"", "{", "newCloud", ",", "err", "=", "c", ".", "readCloudFromFile", "(", "ctxt", ")", "\n", "}", "else", "{", "// No cloud file specified so we try and use a named", "// cloud that already has been added to the local cache.", "newCloud", ",", "err", "=", "cloudFromLocal", "(", "c", ".", "Cloud", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "c", ".", "controllerName", "==", "\"", "\"", "{", "if", "!", "c", ".", "Local", "{", "ctxt", ".", "Infof", "(", "\"", "\\n", "\\n", "\"", ")", "\n", "}", "\n", "return", "addLocalCloud", "(", "c", ".", "cloudMetadataStore", ",", "*", "newCloud", ")", "\n", "}", "\n\n", "// A controller has been specified so upload the cloud details", "// plus a corresponding credential to the controller.", "api", ",", "err", ":=", "c", ".", "addCloudAPIFunc", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "api", ".", "Close", "(", ")", "\n", "err", "=", "api", ".", "AddCloud", "(", "*", "newCloud", ")", "\n", "if", "err", "!=", "nil", "&&", "params", ".", "ErrCode", "(", "err", ")", "!=", "params", ".", "CodeAlreadyExists", "{", "return", "err", "\n", "}", "\n", "// Add a credential for the newly added cloud.", "err", "=", "c", ".", "addCredentialToController", "(", "ctxt", ",", "*", "newCloud", ",", "api", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "ctxt", ".", "Infof", "(", "\"", "\"", ",", "c", ".", "Cloud", ",", "c", ".", "controllerName", ")", "\n", "return", "nil", "\n", "}" ]

[ "Run", "executes", "the", "add", "cloud", "command", "adding", "a", "cloud", "based", "on", "a", "passed", "-", "in", "yaml", "file", "or", "interactive", "queries", "." ]

[ "func", "addCertificate", "(", "data", "[", "]", "byte", ")", "(", "string", ",", "[", "]", "byte", ",", "error", ")", "{", "vals", ",", "err", ":=", "ensureStringMaps", "(", "string", "(", "data", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n", "name", ",", "ok", ":=", "vals", "[", "jujucloud", ".", "CertFilenameKey", "]", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "filename", ":=", "name", ".", "(", "string", ")", "\n", "if", "ok", "&&", "filename", "!=", "\"", "\"", "{", "out", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "filename", ",", "nil", ",", "err", "\n", "}", "\n", "certificate", ":=", "string", "(", "out", ")", "\n", "if", "_", ",", "err", ":=", "cert", ".", "ParseCert", "(", "certificate", ")", ";", "err", "!=", "nil", "{", "return", "filename", ",", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "vals", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "certificate", "}", "\n\n", "}", "else", "{", "return", "filename", ",", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "alt", ",", "err", ":=", "yaml", ".", "Marshal", "(", "vals", ")", "\n", "return", "filename", ",", "alt", ",", "err", "\n", "}" ]

[ "addCertificate", "reads", "the", "cloud", "certificate", "file", "if", "available", "and", "adds", "the", "contents", "to", "the", "byte", "slice", "with", "the", "appropriate", "key", ".", "A", "NotFound", "error", "is", "returned", "if", "a", "cloud", ".", "CertFilenameKey", "is", "not", "contained", "in", "the", "data", "or", "the", "value", "is", "empty", "this", "is", "not", "a", "fatal", "error", "." ]

[ "func", "addableCloudProviders", "(", ")", "(", "providers", "[", "]", "string", ",", "unsupported", "[", "]", "string", ",", "_", "error", ")", "{", "allproviders", ":=", "environs", ".", "RegisteredProviders", "(", ")", "\n", "for", "_", ",", "name", ":=", "range", "allproviders", "{", "provider", ",", "err", ":=", "environs", ".", "Provider", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "// should be impossible", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "provider", ".", "CloudSchema", "(", ")", "!=", "nil", "{", "providers", "=", "append", "(", "providers", ",", "name", ")", "\n", "}", "else", "{", "unsupported", "=", "append", "(", "unsupported", ",", "name", ")", "\n", "}", "\n", "}", "\n", "sort", ".", "Strings", "(", "providers", ")", "\n", "return", "providers", ",", "unsupported", ",", "nil", "\n", "}" ]

[ "addableCloudProviders", "returns", "the", "names", "of", "providers", "supported", "by", "add", "-", "cloud", "and", "also", "the", "names", "of", "those", "which", "are", "not", "supported", "." ]

[ "func", "nameExists", "(", "name", "string", ",", "public", "map", "[", "string", "]", "jujucloud", ".", "Cloud", ")", "(", "string", ",", "error", ")", "{", "if", "_", ",", "ok", ":=", "public", "[", "name", "]", ";", "ok", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ",", "nil", "\n", "}", "\n", "builtin", ",", "err", ":=", "common", ".", "BuiltInClouds", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "builtin", "[", "name", "]", ";", "ok", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "nil", "\n", "}" ]

[ "nameExists", "returns", "either", "an", "empty", "string", "if", "the", "name", "does", "not", "exist", "or", "a", "non", "-", "empty", "string", "with", "an", "error", "message", "if", "it", "does", "exist", "." ]

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

[ "New", "creates", "a", "Facade", "backed", "by", "backend", "and", "resources", ".", "If", "auth", "doesn", "t", "identity", "the", "client", "as", "a", "machine", "agent", "or", "a", "unit", "agent", "it", "will", "return", "common", ".", "ErrPerm", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "Phase", "(", "entities", "params", ".", "Entities", ")", "params", ".", "PhaseResults", "{", "count", ":=", "len", "(", "entities", ".", "Entities", ")", "\n", "results", ":=", "params", ".", "PhaseResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "PhaseResult", ",", "count", ")", ",", "}", "\n", "for", "i", ",", "entity", ":=", "range", "entities", ".", "Entities", "{", "phase", ",", "err", ":=", "facade", ".", "onePhase", "(", "entity", ".", "Tag", ")", "\n", "results", ".", "Results", "[", "i", "]", ".", "Phase", "=", "phase", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "results", "\n", "}" ]

[ "Phase", "returns", "the", "current", "migration", "phase", "or", "an", "error", "for", "every", "supplied", "entity", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "onePhase", "(", "tagString", "string", ")", "(", "string", ",", "error", ")", "{", "if", "err", ":=", "facade", ".", "auth", "(", "tagString", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "phase", ",", "err", ":=", "facade", ".", "backend", ".", "MigrationPhase", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "phase", ".", "String", "(", ")", ",", "nil", "\n", "}" ]

[ "onePhase", "does", "auth", "and", "lookup", "for", "a", "single", "entity", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "Watch", "(", "entities", "params", ".", "Entities", ")", "params", ".", "NotifyWatchResults", "{", "count", ":=", "len", "(", "entities", ".", "Entities", ")", "\n", "results", ":=", "params", ".", "NotifyWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "NotifyWatchResult", ",", "count", ")", ",", "}", "\n", "for", "i", ",", "entity", ":=", "range", "entities", ".", "Entities", "{", "id", ",", "err", ":=", "facade", ".", "oneWatch", "(", "entity", ".", "Tag", ")", "\n", "results", ".", "Results", "[", "i", "]", ".", "NotifyWatcherId", "=", "id", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "results", "\n", "}" ]

[ "Watch", "returns", "an", "id", "for", "use", "with", "the", "NotifyWatcher", "facade", "or", "an", "error", "for", "every", "supplied", "entity", "." ]

[ "func", "Manifold", "(", "config", "ManifoldConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "AgentName", ",", "config", ".", "MetricSpoolName", ",", "config", ".", "CharmDirName", ",", "}", ",", "Start", ":", "func", "(", "context", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "collector", ",", "err", ":=", "newCollect", "(", "config", ",", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "spool", ".", "NewPeriodicWorker", "(", "collector", ".", "Do", ",", "collector", ".", "period", ",", "jworker", ".", "NewTimer", ",", "collector", ".", "stop", ")", ",", "nil", "\n", "}", ",", "}", "\n", "}" ]

[ "Manifold", "returns", "a", "collect", "-", "metrics", "manifold", "." ]

[ "func", "(", "w", "*", "collect", ")", "Do", "(", "stop", "<-", "chan", "struct", "{", "}", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "// See bug https://pad/lv/1733469", "// If this function which is run by a PeriodicWorker", "// exits with an error, we need to call stop() to", "// ensure the listener socket is closed.", "if", "err", "!=", "nil", "{", "w", ".", "stop", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "config", ":=", "w", ".", "agent", ".", "CurrentConfig", "(", ")", "\n", "tag", ":=", "config", ".", "Tag", "(", ")", "\n", "unitTag", ",", "ok", ":=", "tag", ".", "(", "names", ".", "UnitTag", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "tag", ")", "\n", "}", "\n", "paths", ":=", "uniter", ".", "NewWorkerPaths", "(", "config", ".", "DataDir", "(", ")", ",", "unitTag", ",", "\"", "\"", ")", "\n\n", "recorder", ",", "err", ":=", "newRecorder", "(", "unitTag", ",", "paths", ",", "w", ".", "metricFactory", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "errMetricsNotDefined", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "err", "=", "w", ".", "charmdir", ".", "Visit", "(", "func", "(", ")", "error", "{", "return", "w", ".", "runner", ".", "do", "(", "recorder", ")", "\n", "}", ",", "stop", ")", "\n", "if", "err", "==", "fortress", ".", "ErrAborted", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "spool", ".", "IsMetricsDataError", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Do", "satisfies", "the", "worker", ".", "PeriodWorkerCall", "function", "type", "." ]

[ "func", "NewCredentialValidatorAPI", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "CredentialValidatorAPI", ",", "error", ")", "{", "return", "internalNewCredentialValidatorAPI", "(", "NewBackend", "(", "NewStateShim", "(", "ctx", ".", "State", "(", ")", ")", ")", ",", "ctx", ".", "Resources", "(", ")", ",", "ctx", ".", "Auth", "(", ")", ")", "\n", "}" ]

[ "NewCredentialValidatorAPI", "creates", "a", "new", "CredentialValidator", "API", "endpoint", "on", "server", "-", "side", "." ]

[ "func", "NewCredentialValidatorAPIv1", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "CredentialValidatorAPIV1", ",", "error", ")", "{", "v2", ",", "err", ":=", "NewCredentialValidatorAPI", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "CredentialValidatorAPIV1", "{", "v2", "}", ",", "nil", "\n", "}" ]

[ "NewCredentialValidatorAPIv1", "creates", "a", "new", "CredentialValidator", "API", "endpoint", "on", "server", "-", "side", "." ]

[ "func", "(", "api", "*", "CredentialValidatorAPI", ")", "WatchCredential", "(", "tag", "params", ".", "Entity", ")", "(", "params", ".", "NotifyWatchResult", ",", "error", ")", "{", "fail", ":=", "func", "(", "failure", "error", ")", "(", "params", ".", "NotifyWatchResult", ",", "error", ")", "{", "return", "params", ".", "NotifyWatchResult", "{", "}", ",", "common", ".", "ServerError", "(", "failure", ")", "\n", "}", "\n\n", "credentialTag", ",", "err", ":=", "names", ".", "ParseCloudCredentialTag", "(", "tag", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fail", "(", "err", ")", "\n", "}", "\n", "// Is credential used by the model that has created this backend?", "isUsed", ",", "err", ":=", "api", ".", "backend", ".", "ModelUsesCredential", "(", "credentialTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fail", "(", "err", ")", "\n", "}", "\n", "if", "!", "isUsed", "{", "return", "fail", "(", "common", ".", "ErrPerm", ")", "\n", "}", "\n\n", "result", ":=", "params", ".", "NotifyWatchResult", "{", "}", "\n", "watch", ":=", "api", ".", "backend", ".", "WatchCredential", "(", "credentialTag", ")", "\n", "// Consume the initial event. Technically, API calls to Watch", "// 'transmit' the initial event in the Watch response. But", "// NotifyWatchers have no state to transmit.", "if", "_", ",", "ok", ":=", "<-", "watch", ".", "Changes", "(", ")", ";", "ok", "{", "result", ".", "NotifyWatcherId", "=", "api", ".", "resources", ".", "Register", "(", "watch", ")", "\n", "}", "else", "{", "err", "=", "watcher", ".", "EnsureErr", "(", "watch", ")", "\n", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "WatchCredential", "returns", "a", "NotifyWatcher", "that", "observes", "changes", "to", "a", "given", "cloud", "credential", "." ]

[ "func", "(", "api", "*", "CredentialValidatorAPI", ")", "ModelCredential", "(", ")", "(", "params", ".", "ModelCredential", ",", "error", ")", "{", "c", ",", "err", ":=", "api", ".", "backend", ".", "ModelCredential", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "ModelCredential", "{", "}", ",", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n\n", "return", "params", ".", "ModelCredential", "{", "Model", ":", "c", ".", "Model", ".", "String", "(", ")", ",", "CloudCredential", ":", "c", ".", "Credential", ".", "String", "(", ")", ",", "Exists", ":", "c", ".", "Exists", ",", "Valid", ":", "c", ".", "Valid", ",", "}", ",", "nil", "\n", "}" ]

[ "ModelCredential", "returns", "cloud", "credential", "information", "for", "a", "model", "." ]

[ "func", "(", "api", "*", "CredentialValidatorAPI", ")", "WatchModelCredential", "(", ")", "(", "params", ".", "NotifyWatchResult", ",", "error", ")", "{", "result", ":=", "params", ".", "NotifyWatchResult", "{", "}", "\n", "watch", ",", "err", ":=", "api", ".", "backend", ".", "WatchModelCredential", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n\n", "// Consume the initial event. Technically, API calls to Watch", "// 'transmit' the initial event in the Watch response. But", "// NotifyWatchers have no state to transmit.", "if", "_", ",", "ok", ":=", "<-", "watch", ".", "Changes", "(", ")", ";", "ok", "{", "result", ".", "NotifyWatcherId", "=", "api", ".", "resources", ".", "Register", "(", "watch", ")", "\n", "}", "else", "{", "err", "=", "watcher", ".", "EnsureErr", "(", "watch", ")", "\n", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "WatchModelCredential", "returns", "a", "NotifyWatcher", "that", "watches", "what", "cloud", "credential", "a", "model", "uses", "." ]

[ "func", "NewFacade", "(", "resources", "facade", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ",", "st", "CAASUnitProvisionerState", ",", "sb", "StorageBackend", ",", "db", "DeviceBackend", ",", "storagePoolManager", "poolmanager", ".", "PoolManager", ",", "registry", "storage", ".", "ProviderRegistry", ",", "clock", "clock", ".", "Clock", ",", ")", "(", "*", "Facade", ",", "error", ")", "{", "if", "!", "authorizer", ".", "AuthController", "(", ")", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "&", "Facade", "{", "LifeGetter", ":", "common", ".", "NewLifeGetter", "(", "st", ",", "common", ".", "AuthAny", "(", "common", ".", "AuthFuncForTagKind", "(", "names", ".", "ApplicationTagKind", ")", ",", "common", ".", "AuthFuncForTagKind", "(", "names", ".", "UnitTagKind", ")", ",", ")", ",", ")", ",", "resources", ":", "resources", ",", "state", ":", "st", ",", "storage", ":", "sb", ",", "devices", ":", "db", ",", "storagePoolManager", ":", "storagePoolManager", ",", "registry", ":", "registry", ",", "clock", ":", "clock", ",", "}", ",", "nil", "\n", "}" ]

[ "NewFacade", "returns", "a", "new", "CAAS", "unit", "provisioner", "Facade", "facade", "." ]

[ "func", "(", "f", "*", "Facade", ")", "WatchApplicationsScale", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "NotifyWatchResults", ",", "error", ")", "{", "results", ":=", "params", ".", "NotifyWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "NotifyWatchResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Entities", "{", "id", ",", "err", ":=", "f", ".", "watchApplicationScale", "(", "arg", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "NotifyWatcherId", "=", "id", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "WatchApplicationsScale", "starts", "a", "NotifyWatcher", "to", "watch", "changes", "to", "the", "applications", "scale", "." ]

[ "func", "(", "f", "*", "Facade", ")", "WatchPodSpec", "(", "args", "params", ".", "Entities", ")", "(", "params", ".", "NotifyWatchResults", ",", "error", ")", "{", "model", ",", "err", ":=", "f", ".", "state", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "NotifyWatchResults", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "results", ":=", "params", ".", "NotifyWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "NotifyWatchResult", ",", "len", "(", "args", ".", "Entities", ")", ")", ",", "}", "\n", "for", "i", ",", "arg", ":=", "range", "args", ".", "Entities", "{", "id", ",", "err", ":=", "f", ".", "watchPodSpec", "(", "model", ",", "arg", ".", "Tag", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "NotifyWatcherId", "=", "id", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "WatchPodSpec", "starts", "a", "NotifyWatcher", "to", "watch", "changes", "to", "the", "pod", "spec", "for", "specified", "units", "in", "this", "model", "." ]