Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "(", "mongoArgs", "*", "ConfigArgs", ")", "asServiceConf", "(", ")", "common", ".", "Conf", "{", "// See https://docs.mongodb.com/manual/reference/ulimit/.", "limits", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "// file size", "\"", "\"", ":", "\"", "\"", ",", "// cpu time", "\"", "\"", ":", "\"", "\"", ",", "// virtual memory size", "\"", "\"", ":", "\"", "\"", ",", "// locked-in-memory size", "\"", "\"", ":", "\"", "\"", ",", "// open files", "\"", "\"", ":", "\"", "\"", ",", "// processes/threads", "}", "\n", "conf", ":=", "common", ".", "Conf", "{", "Desc", ":", "\"", "\"", ",", "Limit", ":", "limits", ",", "Timeout", ":", "serviceTimeout", ",", "ExecStart", ":", "mongoArgs", ".", "startCommand", "(", ")", ",", "ExtraScript", ":", "mongoArgs", ".", "extraScript", "(", ")", ",", "}", "\n", "return", "conf", "\n", "}" ]

[ "asServiceConf", "returns", "the", "init", "system", "config", "for", "the", "mongo", "state", "service", "." ]

[ "func", "(", "broker", "*", "kvmBroker", ")", "StartInstance", "(", "ctx", "context", ".", "ProviderCallContext", ",", "args", "environs", ".", "StartInstanceParams", ")", "(", "*", "environs", ".", "StartInstanceResult", ",", "error", ")", "{", "// TODO: refactor common code out of the container brokers.", "containerMachineID", ":=", "args", ".", "InstanceConfig", ".", "MachineId", "\n", "kvmLogger", ".", "Infof", "(", "\"", "\"", ",", "containerMachineID", ")", "\n\n", "// TODO: Default to using the host network until we can configure. Yes,", "// this is using the LxcBridge value, we should put it in the api call for", "// container config.", "bridgeDevice", ":=", "broker", ".", "agentConfig", ".", "Value", "(", "agent", ".", "LxcBridge", ")", "\n", "if", "bridgeDevice", "==", "\"", "\"", "{", "bridgeDevice", "=", "network", ".", "DefaultKVMBridge", "\n", "}", "\n\n", "config", ",", "err", ":=", "broker", ".", "api", ".", "ContainerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "kvmLogger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "broker", ".", "prepareHost", "(", "names", ".", "NewMachineTag", "(", "containerMachineID", ")", ",", "kvmLogger", ",", "args", ".", "Abort", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "preparedInfo", ",", "err", ":=", "prepareOrGetContainerInterfaceInfo", "(", "broker", ".", "api", ",", "containerMachineID", ",", "true", ",", "// allocate if possible, do not maintain existing.", "kvmLogger", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Something to fallback to if there are no devices given in args.NetworkInfo", "// TODO(jam): 2017-02-07, this feels like something that should never need", "// to be invoked, because either StartInstance or", "// prepareOrGetContainerInterfaceInfo should always return a value. The", "// test suite currently doesn't think so, and I'm hesitant to munge it too", "// much.", "interfaces", ",", "err", ":=", "finishNetworkConfig", "(", "bridgeDevice", ",", "preparedInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "network", ":=", "container", ".", "BridgeNetworkConfig", "(", "bridgeDevice", ",", "0", ",", "interfaces", ")", "\n\n", "// The provisioner worker will provide all tools it knows about", "// (after applying explicitly specified constraints), which may", "// include tools for architectures other than the host's.", "//", "// container/kvm only allows running container==host arch, so", "// we constrain the tools to host arch here regardless of the", "// constraints specified.", "archTools", ",", "err", ":=", "matchHostArchTools", "(", "args", ".", "Tools", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "series", ":=", "archTools", ".", "OneSeries", "(", ")", "\n", "args", ".", "InstanceConfig", ".", "MachineContainerType", "=", "instance", ".", "KVM", "\n", "if", "err", ":=", "args", ".", "InstanceConfig", ".", "SetTools", "(", "archTools", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "cloudInitUserData", ",", "err", ":=", "combinedCloudInitData", "(", "config", ".", "CloudInitUserData", ",", "config", ".", "ContainerInheritProperties", ",", "series", ",", "kvmLogger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "instancecfg", ".", "PopulateInstanceConfig", "(", "args", ".", "InstanceConfig", ",", "config", ".", "ProviderType", ",", "config", ".", "AuthorizedKeys", ",", "config", ".", "SSLHostnameVerification", ",", "config", ".", "LegacyProxy", ",", "config", ".", "JujuProxy", ",", "config", ".", "AptProxy", ",", "config", ".", "AptMirror", ",", "config", ".", "EnableOSRefreshUpdate", ",", "config", ".", "EnableOSUpgrade", ",", "cloudInitUserData", ",", "nil", ",", ")", ";", "err", "!=", "nil", "{", "kvmLogger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "storageConfig", ":=", "&", "container", ".", "StorageConfig", "{", "AllowMount", ":", "true", ",", "}", "\n", "inst", ",", "hardware", ",", "err", ":=", "broker", ".", "manager", ".", "CreateContainer", "(", "args", ".", "InstanceConfig", ",", "args", ".", "Constraints", ",", "series", ",", "network", ",", "storageConfig", ",", "args", ".", "StatusCallback", ",", ")", "\n", "if", "err", "!=", "nil", "{", "kvmLogger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "kvmLogger", ".", "Infof", "(", "\"", "\"", ",", "containerMachineID", ",", "inst", ".", "Id", "(", ")", ",", "hardware", ".", "String", "(", ")", ")", "\n", "return", "&", "environs", ".", "StartInstanceResult", "{", "Instance", ":", "inst", ",", "Hardware", ":", "hardware", ",", "NetworkInfo", ":", "interfaces", ",", "}", ",", "nil", "\n", "}" ]

[ "StartInstance", "is", "specified", "in", "the", "Broker", "interface", "." ]

[ "func", "NewClient", "(", "st", "base", ".", "APICallCloser", ")", "*", "Client", "{", "frontend", ",", "backend", ":=", "base", ".", "NewClientFacade", "(", "st", ",", "\"", "\"", ")", "\n", "return", "&", "Client", "{", "ClientFacade", ":", "frontend", ",", "st", ":", "st", ",", "facade", ":", "backend", "}", "\n", "}" ]

[ "NewClient", "creates", "a", "new", "client", "for", "accessing", "the", "firewall", "rules", "api", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetFirewallRule", "(", "service", "string", ",", "whiteListCidrs", "[", "]", "string", ")", "error", "{", "serviceValue", ":=", "params", ".", "KnownServiceValue", "(", "service", ")", "\n", "if", "err", ":=", "serviceValue", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "args", ":=", "params", ".", "FirewallRuleArgs", "{", "Args", ":", "[", "]", "params", ".", "FirewallRule", "{", "{", "KnownService", ":", "serviceValue", ",", "WhitelistCIDRS", ":", "whiteListCidrs", ",", "}", "}", ",", "}", "\n", "var", "results", "params", ".", "ErrorResults", "\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "results", ".", "OneError", "(", ")", "\n", "}" ]

[ "SetFirewallRule", "creates", "or", "updates", "a", "firewall", "rule", "." ]

[ "func", "NewVisitor", "(", "username", "string", ",", "getPassword", "func", "(", "string", ")", "(", "string", ",", "error", ")", ")", "*", "Visitor", "{", "return", "&", "Visitor", "{", "username", ":", "username", ",", "getPassword", ":", "getPassword", ",", "}", "\n", "}" ]

[ "NewVisitor", "returns", "a", "new", "Visitor", "." ]

[ "func", "(", "v", "*", "Visitor", ")", "VisitWebPage", "(", "client", "*", "httpbakery", ".", "Client", ",", "methodURLs", "map", "[", "string", "]", "*", "url", ".", "URL", ")", "error", "{", "methodURL", ":=", "methodURLs", "[", "authMethod", "]", "\n", "if", "methodURL", "==", "nil", "{", "return", "httpbakery", ".", "ErrMethodNotSupported", "\n", "}", "\n\n", "password", ",", "err", ":=", "v", ".", "getPassword", "(", "v", ".", "username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// POST to the URL with username and password.", "resp", ",", "err", ":=", "client", ".", "PostForm", "(", "methodURL", ".", "String", "(", ")", ",", "url", ".", "Values", "{", "\"", "\"", ":", "{", "v", ".", "username", "}", ",", "\"", "\"", ":", "{", "password", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n\n", "if", "resp", ".", "StatusCode", "==", "http", ".", "StatusOK", "{", "return", "nil", "\n", "}", "\n", "var", "jsonError", "httpbakery", ".", "Error", "\n", "if", "err", ":=", "json", ".", "NewDecoder", "(", "resp", ".", "Body", ")", ".", "Decode", "(", "&", "jsonError", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "jsonError", "\n", "}" ]

[ "VisitWebPage", "is", "part", "of", "the", "httpbakery", ".", "Visitor", "interface", "." ]

[ "func", "NewMockOperation", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockOperation", "{", "mock", ":=", "&", "MockOperation", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockOperationMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockOperationMockRecorder", ")", "Commit", "(", "arg0", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockOperation", ")", "(", "nil", ")", ".", "Commit", ")", ",", "arg0", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockOperation", ")", "Execute", "(", "arg0", "operation", ".", "State", ")", "(", "*", "operation", ".", "State", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "*", "operation", ".", "State", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "Execute", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockOperation", ")", "NeedsGlobalMachineLock", "(", ")", "bool", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "bool", ")", "\n", "return", "ret0", "\n", "}" ]

[ "NeedsGlobalMachineLock", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockFactory", ")", "NewAcceptLeadership", "(", ")", "(", "operation", ".", "Operation", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "operation", ".", "Operation", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "NewAcceptLeadership", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockFactory", ")", "NewAction", "(", "arg0", "string", ")", "(", "operation", ".", "Operation", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "operation", ".", "Operation", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "NewAction", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockFactory", ")", "NewCommands", "(", "arg0", "operation", ".", "CommandArgs", ",", "arg1", "operation", ".", "CommandResponseFunc", ")", "(", "operation", ".", "Operation", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "operation", ".", "Operation", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "NewCommands", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockFactoryMockRecorder", ")", "NewResignLeadership", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockFactory", ")", "(", "nil", ")", ".", "NewResignLeadership", ")", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockFactory", ")", "NewResolvedUpgrade", "(", "arg0", "*", "charm_v6", ".", "URL", ")", "(", "operation", ".", "Operation", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "operation", ".", "Operation", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "NewResolvedUpgrade", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockFactoryMockRecorder", ")", "NewResolvedUpgrade", "(", "arg0", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockFactory", ")", "(", "nil", ")", ".", "NewResolvedUpgrade", ")", ",", "arg0", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockFactory", ")", "NewRunHook", "(", "arg0", "hook", ".", "Info", ")", "(", "operation", ".", "Operation", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "operation", ".", "Operation", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "NewRunHook", "mocks", "base", "method" ]

[ "func", "(", "c", "pin", ")", "invoke", "(", "ch", "chan", "<-", "pin", ")", "error", "{", "for", "{", "select", "{", "case", "<-", "c", ".", "stop", ":", "return", "errStopped", "\n", "case", "ch", "<-", "c", ":", "ch", "=", "nil", "\n", "case", "err", ":=", "<-", "c", ".", "response", ":", "return", "err", "\n", "}", "\n", "}", "\n", "}" ]

[ "invoke", "sends", "the", "claim", "on", "the", "supplied", "channel", "and", "waits", "for", "a", "response", "." ]

[ "func", "(", "kvm", "*", "kvmInstance", ")", "ClosePorts", "(", "ctx", "context", ".", "ProviderCallContext", ",", "machineId", "string", ",", "rules", "[", "]", "network", ".", "IngressRule", ")", "error", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "ClosePorts", "implements", "instances", ".", "Instance", ".", "ClosePorts", "." ]

[ "func", "New", "(", "caller", "base", ".", "APICaller", ")", "API", "{", "fc", ":=", "base", ".", "NewFacadeCaller", "(", "caller", ",", "uaFacade", ")", "\n", "return", "API", "{", "facade", ":", "fc", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "client", "-", "side", "UnitAssigner", "facade", "." ]

[ "func", "(", "a", "API", ")", "AssignUnits", "(", "tags", "[", "]", "names", ".", "UnitTag", ")", "(", "[", "]", "error", ",", "error", ")", "{", "entities", ":=", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "tags", ")", ")", "\n", "for", "i", ",", "tag", ":=", "range", "tags", "{", "entities", "[", "i", "]", "=", "params", ".", "Entity", "{", "Tag", ":", "tag", ".", "String", "(", ")", "}", "\n", "}", "\n", "args", ":=", "params", ".", "Entities", "{", "Entities", ":", "entities", "}", "\n", "var", "result", "params", ".", "ErrorResults", "\n", "if", "err", ":=", "a", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "errs", ":=", "make", "(", "[", "]", "error", ",", "len", "(", "result", ".", "Results", ")", ")", "\n", "for", "i", ",", "e", ":=", "range", "result", ".", "Results", "{", "if", "e", ".", "Error", "!=", "nil", "{", "errs", "[", "i", "]", "=", "convertNotFound", "(", "e", ".", "Error", ")", "\n", "}", "\n", "}", "\n", "return", "errs", ",", "nil", "\n", "}" ]

[ "AssignUnits", "tells", "the", "controller", "to", "run", "whatever", "unit", "assignments", "it", "has", ".", "Unit", "assignments", "for", "units", "that", "no", "longer", "exist", "will", "return", "an", "error", "that", "satisfies", "errors", ".", "IsNotFound", "." ]

[ "func", "convertNotFound", "(", "err", "error", ")", "error", "{", "if", "params", ".", "IsCodeNotFound", "(", "err", ")", "{", "return", "errors", ".", "NewNotFound", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "convertNotFound", "converts", "param", "notfound", "errors", "into", "errors", ".", "notfound", "values", "." ]

[ "func", "(", "a", "API", ")", "WatchUnitAssignments", "(", ")", "(", "watcher", ".", "StringsWatcher", ",", "error", ")", "{", "var", "result", "params", ".", "StringsWatchResult", "\n", "err", ":=", "a", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n", "w", ":=", "apiwatcher", ".", "NewStringsWatcher", "(", "a", ".", "facade", ".", "RawAPICaller", "(", ")", ",", "result", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "WatchUnitAssignments", "watches", "the", "server", "for", "new", "unit", "assignments", "to", "be", "created", "." ]

[ "func", "(", "a", "API", ")", "SetAgentStatus", "(", "args", "params", ".", "SetStatus", ")", "error", "{", "var", "result", "params", ".", "ErrorResults", "\n", "err", ":=", "a", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "result", ".", "Combine", "(", ")", "\n", "}" ]

[ "SetAgentStatus", "sets", "the", "status", "of", "the", "unit", "agents", "." ]

[ "func", "newService", "(", "name", "string", ",", "conf", "common", ".", "Conf", ",", "initSystem", ",", "series", "string", ")", "(", "Service", ",", "error", ")", "{", "var", "svc", "Service", "\n", "var", "err", "error", "\n\n", "switch", "initSystem", "{", "case", "InitSystemWindows", ":", "svc", ",", "err", "=", "windows", ".", "NewService", "(", "name", ",", "conf", ")", "\n", "case", "InitSystemUpstart", ":", "svc", ",", "err", "=", "upstart", ".", "NewService", "(", "name", ",", "conf", ")", ",", "nil", "\n", "case", "InitSystemSystemd", ":", "svc", ",", "err", "=", "systemd", ".", "NewServiceWithDefaults", "(", "name", ",", "conf", ")", "\n", "case", "InitSystemSnap", ":", "svc", ",", "err", "=", "snap", ".", "NewServiceFromName", "(", "name", ",", "conf", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "initSystem", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "return", "svc", ",", "nil", "\n", "}" ]

[ "this", "needs", "to", "be", "stubbed", "out", "in", "some", "tests" ]

[ "func", "ListServicesScript", "(", ")", "string", "{", "commands", ":=", "[", "]", "string", "{", "\"", "\"", "+", "DiscoverInitSystemScript", "(", ")", "+", "\"", "\"", ",", "// If the init system is not identified then the script will", "// \"exit 1\". This is correct since the script should fail if no", "// init system can be identified.", "newShellSelectCommand", "(", "\"", "\"", ",", "\"", "\"", ",", "listServicesCommand", ")", ",", "}", "\n", "return", "strings", ".", "Join", "(", "commands", ",", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "ListServicesScript", "returns", "the", "commands", "that", "should", "be", "run", "to", "get", "a", "list", "of", "service", "names", "on", "a", "host", "." ]

[ "func", "InstallAndStart", "(", "svc", "ServiceActions", ")", "error", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "svc", ")", "\n", "if", "err", ":=", "svc", ".", "Install", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// For various reasons the init system may take a short time to", "// realise that the service has been installed.", "var", "err", "error", "\n", "for", "attempt", ":=", "installStartRetryAttempts", ".", "Start", "(", ")", ";", "attempt", ".", "Next", "(", ")", ";", "{", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "errors", ".", "Cause", "(", "err", ")", ")", "\n", "}", "\n", "// we attempt restart if the service is running in case daemon parameters", "// have changed, if its not running a regular start will happen.", "if", "err", "=", "ManuallyRestart", "(", "svc", ")", ";", "err", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "svc", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "InstallAndStart", "installs", "the", "provided", "service", "and", "tries", "starting", "it", ".", "The", "first", "few", "Start", "failures", "are", "ignored", "." ]

[ "func", "ManuallyRestart", "(", "svc", "ServiceActions", ")", "error", "{", "// TODO(tsm): fix service.upstart behaviour to match other implementations", "// if restartableService, ok := svc.(RestartableService); ok {", "// \tif err := restartableService.Restart(); err != nil {", "// \t\treturn errors.Trace(err)", "// \t}", "// \treturn nil", "// }", "if", "err", ":=", "svc", ".", "Stop", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "configureableService", ",", "ok", ":=", "svc", ".", "(", "ConfigureableService", ")", "\n", "if", "ok", "&&", "configureableService", ".", "ReConfigureDuringRestart", "(", ")", "{", "if", "err", ":=", "configureableService", ".", "Configure", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "svc", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n\n", "}" ]

[ "ManuallyRestart", "restarts", "the", "service", "by", "applying", "its", "Restart", "method", "or", "by", "falling", "back", "to", "calling", "Stop", "and", "Start" ]

[ "func", "FindUnitServiceNames", "(", "svcNames", "[", "]", "string", ")", "map", "[", "string", "]", "string", "{", "svcMatcher", ":=", "regexp", ".", "MustCompile", "(", "\"", "\"", ")", "\n", "unitServices", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "svc", ":=", "range", "svcNames", "{", "if", "groups", ":=", "svcMatcher", ".", "FindStringSubmatch", "(", "svc", ")", ";", "len", "(", "groups", ")", ">", "0", "{", "unitName", ":=", "groups", "[", "2", "]", "+", "\"", "\"", "+", "groups", "[", "3", "]", "\n", "if", "names", ".", "IsValidUnit", "(", "unitName", ")", "{", "unitServices", "[", "unitName", "]", "=", "groups", "[", "1", "]", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "unitServices", "\n", "}" ]

[ "FindUnitServiceNames", "accepts", "a", "collection", "of", "service", "names", "as", "managed", "by", "the", "local", "init", "system", ".", "Any", "that", "are", "identified", "as", "being", "for", "unit", "agents", "are", "returned", "keyed", "on", "the", "unit", "name", "." ]

[ "func", "EnsureK8sCredential", "(", "config", "*", "clientcmdapi", ".", "Config", ",", "contextName", "string", ")", "(", "*", "clientcmdapi", ".", "Config", ",", "error", ")", "{", "clientset", ",", "err", ":=", "newK8sClientSet", "(", "config", ",", "contextName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "ensureJujuAdminServiceAccount", "(", "clientset", ",", "config", ",", "contextName", ")", "\n", "}" ]

[ "EnsureK8sCredential", "ensures", "juju", "admin", "service", "account", "created", "with", "admin", "cluster", "role", "binding", "setup", "." ]

[ "func", "NewK8sClientConfig", "(", "reader", "io", ".", "Reader", ",", "contextName", ",", "clusterName", "string", ",", "credentialResolver", "K8sCredentialResolver", ")", "(", "*", "ClientConfig", ",", "error", ")", "{", "if", "reader", "==", "nil", "{", "var", "err", "error", "\n", "reader", ",", "err", "=", "readKubeConfigFile", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "content", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "reader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "config", ",", "err", ":=", "parseKubeConfig", "(", "content", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "contexts", ",", "err", ":=", "contextsFromConfig", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "var", "context", "Context", "\n", "if", "contextName", "==", "\"", "\"", "{", "contextName", "=", "config", ".", "CurrentContext", "\n", "}", "\n", "if", "clusterName", "!=", "\"", "\"", "{", "context", ",", "contextName", ",", "err", "=", "pickContextByClusterName", "(", "contexts", ",", "clusterName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "clusterName", ")", "\n", "}", "\n", "}", "else", "if", "contextName", "!=", "\"", "\"", "{", "context", "=", "contexts", "[", "contextName", "]", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "config", ".", "CurrentContext", ")", "\n", "}", "\n", "// exclude not related contexts.", "contexts", "=", "map", "[", "string", "]", "Context", "{", "}", "\n", "if", "contextName", "!=", "\"", "\"", "&&", "!", "context", ".", "isEmpty", "(", ")", "{", "contexts", "[", "contextName", "]", "=", "context", "\n", "}", "\n\n", "// try find everything below based on context.", "clouds", ",", "err", ":=", "cloudsFromConfig", "(", "config", ",", "context", ".", "CloudName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "credentials", ",", "err", ":=", "credentialsFromConfig", "(", "config", ",", "context", ".", "CredentialName", ")", "\n", "if", "errors", ".", "IsNotSupported", "(", "err", ")", "&&", "credentialResolver", "!=", "nil", "{", "// try to generate supported credential using provided credential.", "config", ",", "err", "=", "credentialResolver", "(", "config", ",", "contextName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "context", ".", "CredentialName", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "credentials", ",", "err", "=", "credentialsFromConfig", "(", "config", ",", "context", ".", "CredentialName", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "ClientConfig", "{", "Type", ":", "\"", "\"", ",", "Contexts", ":", "contexts", ",", "CurrentContext", ":", "config", ".", "CurrentContext", ",", "Clouds", ":", "clouds", ",", "Credentials", ":", "credentials", ",", "}", ",", "nil", "\n", "}" ]

[ "NewK8sClientConfig", "returns", "a", "new", "Kubernetes", "client", "reading", "the", "config", "from", "the", "specified", "reader", "." ]

[ "func", "GetKubeConfigPath", "(", ")", "string", "{", "kubeconfig", ":=", "os", ".", "Getenv", "(", "clientcmd", ".", "RecommendedConfigPathEnvVar", ")", "\n", "if", "kubeconfig", "==", "\"", "\"", "{", "kubeconfig", "=", "clientcmd", ".", "RecommendedHomeFile", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "kubeconfig", ")", "\n", "return", "kubeconfig", "\n", "}" ]

[ "GetKubeConfigPath", "-", "define", "kubeconfig", "file", "path", "to", "use" ]

[ "func", "NewRemoteServer", "(", "config", "RemoteServerConfig", ")", "(", "RemoteServer", ",", "error", ")", "{", "remote", ":=", "&", "remoteServer", "{", "origin", ":", "config", ".", "Origin", ",", "target", ":", "config", ".", "Target", ",", "info", ":", "config", ".", "APIInfo", ",", "logger", ":", "config", ".", "Logger", ",", "newWriter", ":", "config", ".", "NewWriter", ",", "hub", ":", "config", ".", "Hub", ",", "clock", ":", "config", ".", "Clock", ",", "pending", ":", "deque", ".", "New", "(", ")", ",", "data", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "unsub", ",", "err", ":=", "remote", ".", "hub", ".", "Subscribe", "(", "forwarder", ".", "ConnectedTopic", ",", "remote", ".", "onForwarderConnection", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "remote", ".", "unsubscribe", "=", "unsub", "\n", "remote", ".", "tomb", ".", "Go", "(", "remote", ".", "loop", ")", "\n", "return", "remote", ",", "nil", "\n", "}" ]

[ "NewRemoteServer", "creates", "a", "new", "RemoteServer", "that", "will", "connect", "to", "the", "remote", "apiserver", "and", "pass", "on", "messages", "to", "the", "pubsub", "endpoint", "of", "that", "apiserver", "." ]

[ "func", "(", "r", "*", "remoteServer", ")", "Report", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "r", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "var", "status", "string", "\n", "if", "r", ".", "connection", "==", "nil", "{", "status", "=", "\"", "\"", "\n", "}", "else", "{", "status", "=", "\"", "\"", "\n", "}", "\n", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "status", ",", "\"", "\"", ":", "r", ".", "info", ".", "Addrs", ",", "\"", "\"", ":", "r", ".", "pending", ".", "Len", "(", ")", ",", "\"", "\"", ":", "r", ".", "sent", ",", "}", "\n", "}" ]

[ "Report", "provides", "information", "to", "the", "engine", "report", ".", "It", "should", "be", "fast", "and", "minimally", "blocking", "." ]

[ "func", "(", "r", "*", "remoteServer", ")", "IntrospectionReport", "(", ")", "string", "{", "r", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "var", "status", "string", "\n", "if", "r", ".", "connection", "==", "nil", "{", "status", "=", "\"", "\"", "\n", "}", "else", "{", "status", "=", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", ",", "status", ",", "r", ".", "info", ".", "Addrs", ",", "r", ".", "pending", ".", "Len", "(", ")", ",", "r", ".", "sent", ")", "\n", "}" ]

[ "IntrospectionReport", "is", "the", "method", "called", "by", "the", "subscriber", "to", "get", "information", "about", "this", "server", "." ]

[ "func", "(", "r", "*", "remoteServer", ")", "UpdateAddresses", "(", "addresses", "[", "]", "string", ")", "{", "r", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "r", ".", "connection", "==", "nil", "&&", "r", ".", "stopConnecting", "!=", "nil", "{", "// We are probably trying to reconnect, so interrupt that so we don't", "// get a race between setting addresses and trying to read them to", "// connect. Note that we don't call the interruptConnecting method", "// here because that method also tries to lock the mutex.", "r", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "addresses", ")", "\n", "close", "(", "r", ".", "stopConnecting", ")", "\n", "r", ".", "stopConnecting", "=", "nil", "\n", "}", "\n", "r", ".", "info", ".", "Addrs", "=", "addresses", "\n", "}" ]

[ "UpdateAddresses", "will", "update", "the", "addresses", "held", "for", "the", "target", "API", "server", ".", "If", "we", "are", "currently", "trying", "to", "connect", "to", "the", "target", "interrupt", "it", "so", "we", "can", "try", "again", "with", "the", "new", "addresses", "." ]

[ "func", "(", "r", "*", "remoteServer", ")", "Publish", "(", "message", "*", "params", ".", "PubSubMessage", ")", "{", "select", "{", "case", "<-", "r", ".", "tomb", ".", "Dying", "(", ")", ":", "r", ".", "logger", ".", "Tracef", "(", "\"", "\"", ",", "message", ".", "Topic", ")", "\n", "default", ":", "r", ".", "mutex", ".", "Lock", "(", ")", "\n", "// Only queue the message up if we are currently connected.", "notifyData", ":=", "false", "\n", "if", "r", ".", "connection", "!=", "nil", "{", "r", ".", "logger", ".", "Tracef", "(", "\"", "\"", ",", "message", ".", "Topic", ")", "\n", "r", ".", "pending", ".", "PushBack", "(", "message", ")", "\n", "notifyData", "=", "r", ".", "pending", ".", "Len", "(", ")", "==", "1", "\n\n", "}", "else", "{", "r", ".", "logger", ".", "Tracef", "(", "\"", "\"", ",", "message", ".", "Topic", ",", "r", ".", "target", ")", "\n", "}", "\n", "r", ".", "mutex", ".", "Unlock", "(", ")", "\n", "if", "notifyData", "{", "select", "{", "case", "r", ".", "data", "<-", "struct", "{", "}", "{", "}", ":", "case", "<-", "r", ".", "connectionReset", ":", "r", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "message", ".", "Topic", ",", "r", ".", "target", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Publish", "queues", "up", "the", "message", "if", "and", "only", "if", "we", "have", "an", "active", "connection", "to", "the", "target", "apiserver", "." ]

[ "func", "(", "r", "*", "remoteServer", ")", "nextMessage", "(", ")", "*", "params", ".", "PubSubMessage", "{", "r", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "mutex", ".", "Unlock", "(", ")", "\n", "val", ",", "ok", ":=", "r", ".", "pending", ".", "PopFront", "(", ")", "\n", "if", "!", "ok", "{", "// nothing to do", "return", "nil", "\n", "}", "\n", "// Even though it isn't exactly sent right now, it effectively will", "// be very soon, and we want to keep this counter in the mutex lock.", "r", ".", "sent", "++", "\n", "return", "val", ".", "(", "*", "params", ".", "PubSubMessage", ")", "\n", "}" ]

[ "nextMessage", "returns", "the", "next", "queued", "message", "and", "a", "flag", "to", "indicate", "empty", "." ]

[ "func", "(", "r", "*", "remoteServer", ")", "forwardMessages", "(", "messageToSend", "<-", "chan", "*", "params", ".", "PubSubMessage", ",", "messageSent", "chan", "<-", "*", "params", ".", "PubSubMessage", ")", "{", "var", "message", "*", "params", ".", "PubSubMessage", "\n", "for", "{", "select", "{", "case", "<-", "r", ".", "tomb", ".", "Dying", "(", ")", ":", "return", "\n", "case", "message", "=", "<-", "messageToSend", ":", "}", "\n", "r", ".", "mutex", ".", "Lock", "(", ")", "\n", "conn", ":=", "r", ".", "connection", "\n", "r", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "r", ".", "logger", ".", "Tracef", "(", "\"", "\"", ",", "message", ".", "Topic", ",", "r", ".", "target", ",", "message", ".", "Data", ")", "\n", "if", "conn", "!=", "nil", "{", "err", ":=", "conn", ".", "ForwardMessage", "(", "message", ")", "\n", "if", "err", "!=", "nil", "{", "// Some problem sending, so log, close the connection, and try to reconnect.", "r", ".", "logger", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "r", ".", "resetConnection", "(", ")", "\n", "}", "\n", "}", "\n\n", "select", "{", "case", "<-", "r", ".", "tomb", ".", "Dying", "(", ")", ":", "return", "\n", "case", "messageSent", "<-", "message", ":", "}", "\n", "}", "\n", "}" ]

[ "forwardMessages", "is", "a", "goroutine", "whose", "sole", "purpose", "is", "to", "get", "messages", "off", "the", "messageToSend", "channel", "try", "to", "send", "them", "over", "the", "API", "and", "say", "when", "they", "are", "done", "with", "this", "message", ".", "This", "allows", "for", "the", "potential", "blocking", "call", "of", "ForwardMessage", ".", "If", "this", "does", "block", "for", "whatever", "reason", "and", "the", "worker", "is", "asked", "to", "shutdown", "the", "main", "loop", "method", "is", "able", "to", "do", "so", ".", "That", "would", "cause", "the", "API", "connection", "to", "be", "closed", "which", "would", "cause", "the", "ForwardMessage", "to", "be", "unblocked", "due", "to", "the", "error", "of", "the", "socket", "closing", "." ]

[ "func", "(", "s", "*", "precheckShim", ")", "Model", "(", ")", "(", "PrecheckModel", ",", "error", ")", "{", "model", ",", "err", ":=", "s", ".", "State", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "model", ",", "nil", "\n", "}" ]

[ "Model", "implements", "PrecheckBackend", "." ]

[ "func", "(", "s", "*", "precheckShim", ")", "IsMigrationActive", "(", "modelUUID", "string", ")", "(", "bool", ",", "error", ")", "{", "return", "state", ".", "IsMigrationActive", "(", "s", ".", "State", ",", "modelUUID", ")", "\n", "}" ]

[ "IsMigrationActive", "implements", "PrecheckBackend", "." ]

[ "func", "(", "s", "*", "precheckShim", ")", "AgentVersion", "(", ")", "(", "version", ".", "Number", ",", "error", ")", "{", "model", ",", "err", ":=", "s", ".", "State", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "version", ".", "Zero", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "cfg", ",", "err", ":=", "model", ".", "ModelConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "version", ".", "Zero", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "vers", ",", "ok", ":=", "cfg", ".", "AgentVersion", "(", ")", "\n", "if", "!", "ok", "{", "return", "version", ".", "Zero", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "vers", ",", "nil", "\n", "}" ]

[ "AgentVersion", "implements", "PrecheckBackend", "." ]

[ "func", "(", "s", "*", "precheckShim", ")", "AllMachines", "(", ")", "(", "[", "]", "PrecheckMachine", ",", "error", ")", "{", "machines", ",", "err", ":=", "s", ".", "State", ".", "AllMachines", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "out", ":=", "make", "(", "[", "]", "PrecheckMachine", ",", "0", ",", "len", "(", "machines", ")", ")", "\n", "for", "_", ",", "machine", ":=", "range", "machines", "{", "out", "=", "append", "(", "out", ",", "machine", ")", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "AllMachines", "implements", "PrecheckBackend", "." ]

[ "func", "(", "s", "*", "precheckShim", ")", "AllApplications", "(", ")", "(", "[", "]", "PrecheckApplication", ",", "error", ")", "{", "apps", ",", "err", ":=", "s", ".", "State", ".", "AllApplications", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "out", ":=", "make", "(", "[", "]", "PrecheckApplication", ",", "0", ",", "len", "(", "apps", ")", ")", "\n", "for", "_", ",", "app", ":=", "range", "apps", "{", "out", "=", "append", "(", "out", ",", "&", "precheckAppShim", "{", "app", "}", ")", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "AllApplications", "implements", "PrecheckBackend", "." ]

[ "func", "(", "s", "*", "precheckShim", ")", "ListPendingResources", "(", "app", "string", ")", "(", "[", "]", "resource", ".", "Resource", ",", "error", ")", "{", "resources", ",", "err", ":=", "s", ".", "resourcesSt", ".", "ListPendingResources", "(", "app", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "resources", ",", "nil", "\n", "}" ]

[ "ListPendingResources", "implements", "PrecheckBackend", "." ]

[ "func", "(", "s", "*", "precheckShim", ")", "ControllerBackend", "(", ")", "(", "PrecheckBackend", ",", "error", ")", "{", "return", "PrecheckShim", "(", "s", ".", "controllerState", ",", "s", ".", "controllerState", ")", "\n", "}" ]

[ "ControllerBackend", "implements", "PrecheckBackend", "." ]

[ "func", "(", "s", "*", "precheckAppShim", ")", "AllUnits", "(", ")", "(", "[", "]", "PrecheckUnit", ",", "error", ")", "{", "units", ",", "err", ":=", "s", ".", "Application", ".", "AllUnits", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "out", ":=", "make", "(", "[", "]", "PrecheckUnit", ",", "0", ",", "len", "(", "units", ")", ")", "\n", "for", "_", ",", "unit", ":=", "range", "units", "{", "out", "=", "append", "(", "out", ",", "unit", ")", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "AllUnits", "implements", "PrecheckApplication", "." ]

[ "func", "(", "s", "*", "precheckRelationShim", ")", "Unit", "(", "pu", "PrecheckUnit", ")", "(", "PrecheckRelationUnit", ",", "error", ")", "{", "u", ",", "ok", ":=", "pu", ".", "(", "*", "state", ".", "Unit", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "pu", ")", "\n", "}", "\n", "ru", ",", "err", ":=", "s", ".", "Relation", ".", "Unit", "(", "u", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "ru", ",", "nil", "\n", "}" ]

[ "Unit", "implements", "PreCheckRelation", "." ]

[ "func", "(", "s", "*", "precheckRelationShim", ")", "IsCrossModel", "(", ")", "(", "bool", ",", "error", ")", "{", "_", ",", "result", ",", "err", ":=", "s", ".", "Relation", ".", "RemoteApplication", "(", ")", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "IsCrossModel", "implements", "PreCheckRelation", "." ]

[ "func", "NewMockApiExtensionsClientInterface", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockApiExtensionsClientInterface", "{", "mock", ":=", "&", "MockApiExtensionsClientInterface", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockApiExtensionsClientInterfaceMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockApiExtensionsClientInterface", ")", "Apiextensions", "(", ")", "v1beta1", ".", "ApiextensionsV1beta1Interface", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "v1beta1", ".", "ApiextensionsV1beta1Interface", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Apiextensions", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockApiExtensionsClientInterfaceMockRecorder", ")", "Apiextensions", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockApiExtensionsClientInterface", ")", "(", "nil", ")", ".", "Apiextensions", ")", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockApiExtensionsClientInterface", ")", "Discovery", "(", ")", "discovery", ".", "DiscoveryInterface", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "discovery", ".", "DiscoveryInterface", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Discovery", "mocks", "base", "method" ]

[ "func", "AddTrustSchemaAndDefaults", "(", "schema", "environschema", ".", "Fields", ",", "defaults", "schema", ".", "Defaults", ")", "(", "environschema", ".", "Fields", ",", "schema", ".", "Defaults", ",", "error", ")", "{", "newSchema", ",", "err", ":=", "addTrustSchema", "(", "schema", ")", "\n", "newDefaults", ":=", "addTrustDefaults", "(", "defaults", ")", "\n", "return", "newSchema", ",", "newDefaults", ",", "err", "\n", "}" ]

[ "AddTrustSchemaAndDefaults", "adds", "trust", "schema", "fields", "and", "defaults", "to", "an", "existing", "set", "of", "schema", "fields", "and", "defaults", "." ]

[ "func", "(", "st", "*", "State", ")", "ControllerTimestamp", "(", ")", "(", "*", "time", ".", "Time", ",", "error", ")", "{", "now", ":=", "st", ".", "clock", "(", ")", ".", "Now", "(", ")", "\n", "return", "&", "now", ",", "nil", "\n", "}" ]

[ "ControllerTimestamp", "returns", "the", "current", "timestamp", "of", "the", "backend", "controller", "." ]

[ "func", "(", "st", "*", "State", ")", "ControllerOwner", "(", ")", "(", "names", ".", "UserTag", ",", "error", ")", "{", "models", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "modelsC", ")", "\n", "defer", "closer", "(", ")", "\n", "var", "doc", "map", "[", "string", "]", "string", "\n", "err", ":=", "models", ".", "FindId", "(", "st", ".", "ControllerModelUUID", "(", ")", ")", ".", "Select", "(", "bson", ".", "M", "{", "\"", "\"", ":", "1", "}", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "names", ".", "UserTag", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "owner", ":=", "doc", "[", "\"", "\"", "]", "\n", "if", "owner", "==", "\"", "\"", "{", "return", "names", ".", "UserTag", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "names", ".", "NewUserTag", "(", "owner", ")", ",", "nil", "\n", "}" ]

[ "ControllerOwner", "returns", "the", "owner", "of", "the", "controller", "model", "." ]

[ "func", "(", "st", "*", "State", ")", "setDyingModelToDead", "(", ")", "error", "{", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "model", ".", "Life", "(", ")", "!=", "Dying", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "ErrModelNotDying", ")", "\n", "}", "\n", "ops", ":=", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "modelsC", ",", "Id", ":", "st", ".", "ModelUUID", "(", ")", ",", "Assert", ":", "isDyingDoc", ",", "Update", ":", "bson", ".", "M", "{", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "Dead", ",", "\"", "\"", ":", "st", ".", "nowToTheSecond", "(", ")", ",", "}", "}", ",", "}", ",", "{", "// Cleanup the owner:modelName unique key.", "C", ":", "usermodelnameC", ",", "Id", ":", "model", ".", "uniqueIndexID", "(", ")", ",", "Remove", ":", "true", ",", "}", "}", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "if", "err", ":=", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setDyingModelToDead", "sets", "current", "dying", "model", "to", "dead", "." ]

[ "func", "(", "st", "*", "State", ")", "RemoveDyingModel", "(", ")", "error", "{", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "model", ".", "Life", "(", ")", "==", "Alive", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "model", ".", "Life", "(", ")", "==", "Dying", "{", "// set model to dead if it's dying.", "if", "err", "=", "st", ".", "setDyingModelToDead", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "err", "=", "st", ".", "removeAllModelDocs", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "Dead", "}", "}", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "txn", ".", "ErrAborted", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "RemoveDyingModel", "sets", "current", "model", "to", "dead", "then", "removes", "all", "documents", "from", "multi", "-", "model", "collections", "." ]

[ "func", "(", "st", "*", "State", ")", "RemoveImportingModelDocs", "(", ")", "error", "{", "err", ":=", "st", ".", "removeAllModelDocs", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "MigrationModeImporting", "}", "}", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "txn", ".", "ErrAborted", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "RemoveImportingModelDocs", "removes", "all", "documents", "from", "multi", "-", "model", "collections", "for", "the", "current", "model", ".", "This", "method", "asserts", "that", "the", "model", "s", "migration", "mode", "is", "importing", "." ]

[ "func", "(", "st", "*", "State", ")", "RemoveExportingModelDocs", "(", ")", "error", "{", "err", ":=", "st", ".", "removeAllModelDocs", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "MigrationModeExporting", "}", "}", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "txn", ".", "ErrAborted", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "RemoveExportingModelDocs", "removes", "all", "documents", "from", "multi", "-", "model", "collections", "for", "the", "current", "model", ".", "This", "method", "asserts", "that", "the", "model", "s", "migration", "mode", "is", "exporting", "." ]

[ "func", "(", "st", "*", "State", ")", "removeAllInCollectionRaw", "(", "name", "string", ")", "error", "{", "coll", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "name", ")", "\n", "defer", "closer", "(", ")", "\n", "_", ",", "err", ":=", "coll", ".", "Writeable", "(", ")", ".", "RemoveAll", "(", "nil", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "removeAllInCollectionRaw", "removes", "all", "the", "documents", "from", "the", "given", "named", "collection", "." ]

[ "func", "(", "st", "*", "State", ")", "removeAllInCollectionOps", "(", "name", "string", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "return", "st", ".", "removeInCollectionOps", "(", "name", ",", "nil", ")", "\n", "}" ]

[ "removeAllInCollectionOps", "appends", "to", "ops", "operations", "to", "remove", "all", "the", "documents", "in", "the", "given", "named", "collection", "." ]

[ "func", "(", "st", "*", "State", ")", "removeInCollectionOps", "(", "name", "string", ",", "sel", "interface", "{", "}", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "coll", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "name", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "ids", "[", "]", "bson", ".", "M", "\n", "err", ":=", "coll", ".", "Find", "(", "sel", ")", ".", "Select", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", ")", ".", "All", "(", "&", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "ops", "[", "]", "txn", ".", "Op", "\n", "for", "_", ",", "id", ":=", "range", "ids", "{", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "name", ",", "Id", ":", "id", "[", "\"", "\"", "]", ",", "Remove", ":", "true", ",", "}", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}" ]

[ "removeInCollectionOps", "generates", "operations", "to", "remove", "all", "documents", "from", "the", "named", "collection", "matching", "a", "specific", "selector", "." ]

[ "func", "(", "st", "*", "State", ")", "ApplicationLeaders", "(", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "config", ",", "err", ":=", "st", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "config", ".", "Features", "(", ")", ".", "Contains", "(", "feature", ".", "LegacyLeases", ")", "{", "return", "raftleasestore", ".", "LeaseHolders", "(", "&", "environMongo", "{", "st", "}", ",", "leaseHoldersC", ",", "lease", ".", "ApplicationLeadershipNamespace", ",", "st", ".", "ModelUUID", "(", ")", ",", ")", "\n", "}", "\n", "store", ",", "err", ":=", "st", ".", "getLeadershipLeaseStore", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "leases", ":=", "store", ".", "Leases", "(", ")", "\n", "result", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "leases", ")", ")", "\n", "for", "key", ",", "value", ":=", "range", "leases", "{", "result", "[", "key", ".", "Lease", "]", "=", "value", ".", "Holder", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "ApplicationLeaders", "returns", "a", "map", "of", "the", "application", "name", "to", "the", "unit", "name", "that", "is", "the", "current", "leader", "." ]

[ "func", "(", "st", "*", "State", ")", "LeaseNotifyTarget", "(", "logDest", "io", ".", "Writer", ",", "errorLogger", "raftleasestore", ".", "Logger", ")", "raftlease", ".", "NotifyTarget", "{", "return", "raftleasestore", ".", "NewNotifyTarget", "(", "&", "environMongo", "{", "st", "}", ",", "leaseHoldersC", ",", "logDest", ",", "errorLogger", ")", "\n", "}" ]

[ "LeaseNotifyTarget", "returns", "a", "raftlease", ".", "NotifyTarget", "for", "storing", "lease", "changes", "in", "the", "database", "." ]

[ "func", "(", "st", "*", "State", ")", "LeaseTrapdoorFunc", "(", ")", "raftlease", ".", "TrapdoorFunc", "{", "return", "raftleasestore", ".", "MakeTrapdoorFunc", "(", "&", "environMongo", "{", "st", "}", ",", "leaseHoldersC", ")", "\n", "}" ]

[ "LeaseTrapdoorFunc", "returns", "a", "raftlease", ".", "TrapdoorFunc", "for", "checking", "lease", "state", "in", "a", "database", "." ]

[ "func", "(", "st", "*", "State", ")", "EnsureModelRemoved", "(", ")", "error", "{", "found", ":=", "map", "[", "string", "]", "int", "{", "}", "\n", "var", "foundOrdered", "[", "]", "string", "\n", "for", "name", ",", "info", ":=", "range", "st", ".", "database", ".", "Schema", "(", ")", "{", "if", "info", ".", "global", "{", "continue", "\n", "}", "\n", "coll", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "name", ")", "\n", "defer", "closer", "(", ")", "\n", "n", ",", "err", ":=", "coll", ".", "Find", "(", "nil", ")", ".", "Count", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "n", "!=", "0", "{", "found", "[", "name", "]", "=", "n", "\n", "foundOrdered", "=", "append", "(", "foundOrdered", ",", "name", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "found", ")", "!=", "0", "{", "errMessage", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "st", ".", "ModelUUID", "(", ")", ")", "\n", "sort", ".", "Strings", "(", "foundOrdered", ")", "\n", "for", "_", ",", "name", ":=", "range", "foundOrdered", "{", "number", ":=", "found", "[", "name", "]", "\n", "errMessage", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "number", ",", "name", ")", "\n", "}", "\n", "// Remove trailing comma.", "errMessage", "=", "errMessage", "[", ":", "len", "(", "errMessage", ")", "-", "1", "]", "\n", "return", "errors", ".", "New", "(", "errMessage", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "EnsureModelRemoved", "returns", "an", "error", "if", "any", "multi", "-", "model", "documents", "for", "this", "model", "are", "found", ".", "It", "is", "intended", "only", "to", "be", "used", "in", "tests", "and", "exported", "so", "it", "can", "be", "used", "in", "the", "tests", "of", "other", "packages", "." ]

[ "func", "(", "st", "*", "State", ")", "MongoVersion", "(", ")", "(", "string", ",", "error", ")", "{", "binfo", ",", "err", ":=", "st", ".", "session", ".", "BuildInfo", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "binfo", ".", "Version", ",", "nil", "\n", "}" ]

[ "MongoVersion", "return", "the", "string", "repre" ]

[ "func", "newVersionInconsistentError", "(", "currentVersion", "version", ".", "Number", ",", "agents", "[", "]", "string", ")", "*", "versionInconsistentError", "{", "return", "&", "versionInconsistentError", "{", "currentVersion", ",", "agents", "}", "\n", "}" ]

[ "newVersionInconsistentError", "returns", "a", "new", "instance", "of", "versionInconsistentError", "." ]

[ "func", "IsVersionInconsistentError", "(", "e", "interface", "{", "}", ")", "bool", "{", "value", ":=", "e", "\n", "// In case of a wrapped error, check the cause first.", "cause", ":=", "errors", ".", "Cause", "(", "e", ".", "(", "error", ")", ")", "\n", "if", "cause", "!=", "nil", "{", "value", "=", "cause", "\n", "}", "\n", "_", ",", "ok", ":=", "value", ".", "(", "*", "versionInconsistentError", ")", "\n", "return", "ok", "\n", "}" ]

[ "IsVersionInconsistentError", "returns", "if", "the", "given", "error", "is", "versionInconsistentError", "." ]

[ "func", "(", "st", "*", "State", ")", "ModelConstraints", "(", ")", "(", "constraints", ".", "Value", ",", "error", ")", "{", "cons", ",", "err", ":=", "readConstraints", "(", "st", ",", "modelGlobalKey", ")", "\n", "return", "cons", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "ModelConstraints", "returns", "the", "current", "model", "constraints", "." ]

[ "func", "(", "st", "*", "State", ")", "SetModelConstraints", "(", "cons", "constraints", ".", "Value", ")", "error", "{", "unsupported", ",", "err", ":=", "st", ".", "validateConstraints", "(", "cons", ")", "\n", "if", "len", "(", "unsupported", ")", ">", "0", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "unsupported", ",", "\"", "\"", ")", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "writeConstraints", "(", "st", ",", "modelGlobalKey", ",", "cons", ")", "\n", "}" ]

[ "SetModelConstraints", "replaces", "the", "current", "model", "constraints", "." ]

[ "func", "(", "st", "*", "State", ")", "AllMachines", "(", ")", "(", "[", "]", "*", "Machine", ",", "error", ")", "{", "machinesCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "machinesC", ")", "\n", "defer", "closer", "(", ")", "\n", "return", "st", ".", "allMachines", "(", "machinesCollection", ")", "\n", "}" ]

[ "AllMachines", "returns", "all", "machines", "in", "the", "model", "ordered", "by", "id", "." ]

[ "func", "(", "st", "*", "State", ")", "Machine", "(", "id", "string", ")", "(", "*", "Machine", ",", "error", ")", "{", "mdoc", ",", "err", ":=", "st", ".", "getMachineDoc", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "newMachine", "(", "st", ",", "mdoc", ")", ",", "nil", "\n", "}" ]

[ "Machine", "returns", "the", "machine", "with", "the", "given", "id", "." ]

[ "func", "(", "st", "*", "State", ")", "tagToCollectionAndId", "(", "tag", "names", ".", "Tag", ")", "(", "string", ",", "interface", "{", "}", ",", "error", ")", "{", "if", "tag", "==", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "coll", ":=", "\"", "\"", "\n", "id", ":=", "tag", ".", "Id", "(", ")", "\n", "switch", "tag", ":=", "tag", ".", "(", "type", ")", "{", "case", "names", ".", "MachineTag", ":", "coll", "=", "machinesC", "\n", "id", "=", "st", ".", "docID", "(", "id", ")", "\n", "case", "names", ".", "ApplicationTag", ":", "coll", "=", "applicationsC", "\n", "id", "=", "st", ".", "docID", "(", "id", ")", "\n", "case", "names", ".", "UnitTag", ":", "coll", "=", "unitsC", "\n", "id", "=", "st", ".", "docID", "(", "id", ")", "\n", "case", "names", ".", "UserTag", ":", "coll", "=", "usersC", "\n", "if", "!", "tag", ".", "IsLocal", "(", ")", "{", "return", "\"", "\"", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "}", "\n", "id", "=", "tag", ".", "Name", "(", ")", "\n", "case", "names", ".", "RelationTag", ":", "coll", "=", "relationsC", "\n", "id", "=", "st", ".", "docID", "(", "id", ")", "\n", "case", "names", ".", "ModelTag", ":", "coll", "=", "modelsC", "\n", "case", "names", ".", "ActionTag", ":", "coll", "=", "actionsC", "\n", "id", "=", "tag", ".", "Id", "(", ")", "\n", "case", "names", ".", "CharmTag", ":", "coll", "=", "charmsC", "\n", "id", "=", "tag", ".", "Id", "(", ")", "\n", "default", ":", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "tag", ")", "\n", "}", "\n", "return", "coll", ",", "id", ",", "nil", "\n", "}" ]

[ "tagToCollectionAndId", "given", "an", "entity", "tag", "returns", "the", "collection", "name", "and", "id", "of", "the", "entity", "document", "." ]

[ "func", "(", "st", "*", "State", ")", "addPeerRelationsOps", "(", "applicationname", "string", ",", "peers", "map", "[", "string", "]", "charm", ".", "Relation", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "now", ":=", "st", ".", "clock", "(", ")", ".", "Now", "(", ")", "\n", "var", "ops", "[", "]", "txn", ".", "Op", "\n", "for", "_", ",", "rel", ":=", "range", "peers", "{", "relId", ",", "err", ":=", "sequence", "(", "st", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "eps", ":=", "[", "]", "Endpoint", "{", "{", "ApplicationName", ":", "applicationname", ",", "Relation", ":", "rel", ",", "}", "}", "\n", "relKey", ":=", "relationKey", "(", "eps", ")", "\n", "relDoc", ":=", "&", "relationDoc", "{", "DocID", ":", "st", ".", "docID", "(", "relKey", ")", ",", "Key", ":", "relKey", ",", "ModelUUID", ":", "st", ".", "ModelUUID", "(", ")", ",", "Id", ":", "relId", ",", "Endpoints", ":", "eps", ",", "Life", ":", "Alive", ",", "}", "\n", "relationStatusDoc", ":=", "statusDoc", "{", "Status", ":", "status", ".", "Joining", ",", "ModelUUID", ":", "st", ".", "ModelUUID", "(", ")", ",", "Updated", ":", "now", ".", "UnixNano", "(", ")", ",", "}", "\n", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "relationsC", ",", "Id", ":", "relDoc", ".", "DocID", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "relDoc", ",", "}", ",", "createStatusOp", "(", "st", ",", "relationGlobalScope", "(", "relId", ")", ",", "relationStatusDoc", ")", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}" ]

[ "addPeerRelationsOps", "returns", "the", "operations", "necessary", "to", "add", "the", "specified", "application", "peer", "relations", "to", "the", "state", "." ]

[ "func", "(", "st", "*", "State", ")", "SaveCloudService", "(", "args", "SaveCloudServiceArgs", ")", "(", "_", "*", "CloudService", ",", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "args", ".", "ProviderId", ")", "\n\n", "doc", ":=", "cloudServiceDoc", "{", "DocID", ":", "applicationGlobalKey", "(", "args", ".", "Id", ")", ",", "ProviderId", ":", "args", ".", "ProviderId", ",", "Addresses", ":", "fromNetworkAddresses", "(", "args", ".", "Addresses", ",", "OriginProvider", ")", ",", "}", "\n", "svc", ":=", "newCloudService", "(", "st", ",", "&", "doc", ")", "\n", "buildTxn", ":=", "func", "(", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "return", "svc", ".", "saveServiceOps", "(", "doc", ")", "\n", "}", "\n\n", "if", "err", ":=", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "svc", ",", "nil", "\n", "}" ]

[ "SaveCloudService", "creates", "a", "cloud", "service", "." ]

[ "func", "(", "st", "*", "State", ")", "CloudService", "(", "id", "string", ")", "(", "*", "CloudService", ",", "error", ")", "{", "svc", ":=", "newCloudService", "(", "st", ",", "&", "cloudServiceDoc", "{", "DocID", ":", "st", ".", "docID", "(", "applicationGlobalKey", "(", "id", ")", ")", "}", ")", "\n", "return", "svc", ".", "CloudService", "(", ")", "\n", "}" ]

[ "CloudService", "returns", "a", "cloud", "service", "state", "by", "Id", "." ]

[ "func", "removeNils", "(", "m", "map", "[", "string", "]", "interface", "{", "}", ")", "{", "for", "k", ",", "v", ":=", "range", "m", "{", "if", "v", "==", "nil", "{", "delete", "(", "m", ",", "k", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "removeNils", "removes", "any", "keys", "with", "nil", "values", "from", "the", "given", "map", "." ]

[ "func", "assignUnitOps", "(", "unitName", "string", ",", "placement", "instance", ".", "Placement", ")", "[", "]", "txn", ".", "Op", "{", "udoc", ":=", "assignUnitDoc", "{", "DocId", ":", "unitName", ",", "Scope", ":", "placement", ".", "Scope", ",", "Directive", ":", "placement", ".", "Directive", ",", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "assignUnitC", ",", "Id", ":", "udoc", ".", "DocId", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "udoc", ",", "}", "}", "\n", "}" ]

[ "assignUnitOps", "returns", "the", "db", "ops", "to", "save", "unit", "assignment", "for", "use", "by", "the", "UnitAssigner", "worker", "." ]

[ "func", "(", "st", "*", "State", ")", "AssignStagedUnits", "(", "ids", "[", "]", "string", ")", "(", "[", "]", "UnitAssignmentResult", ",", "error", ")", "{", "query", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "ids", "}", "}", "}", "}", "\n", "unitAssignments", ",", "err", ":=", "st", ".", "unitAssignments", "(", "query", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "results", ":=", "make", "(", "[", "]", "UnitAssignmentResult", ",", "len", "(", "unitAssignments", ")", ")", "\n", "for", "i", ",", "a", ":=", "range", "unitAssignments", "{", "err", ":=", "st", ".", "assignStagedUnit", "(", "a", ")", "\n", "results", "[", "i", "]", ".", "Unit", "=", "a", ".", "Unit", "\n", "results", "[", "i", "]", ".", "Error", "=", "err", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "AssignStagedUnits", "gets", "called", "by", "the", "UnitAssigner", "worker", "and", "runs", "the", "given", "assignments", "." ]

[ "func", "(", "st", "*", "State", ")", "AssignUnitWithPlacement", "(", "unit", "*", "Unit", ",", "placement", "*", "instance", ".", "Placement", ")", "error", "{", "// TODO(natefinch) this should be done as a single transaction, not two.", "// Mark https://launchpad.net/bugs/1506994 fixed when done.", "data", ",", "err", ":=", "st", ".", "parsePlacement", "(", "placement", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "data", ".", "placementType", "(", ")", "==", "directivePlacement", "{", "return", "unit", ".", "assignToNewMachine", "(", "data", ".", "directive", ")", "\n", "}", "\n\n", "m", ",", "err", ":=", "st", ".", "addMachineWithPlacement", "(", "unit", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "unit", ".", "AssignToMachine", "(", "m", ")", "\n", "}" ]

[ "AssignUnitWithPlacement", "chooses", "a", "machine", "using", "the", "given", "placement", "directive", "and", "then", "assigns", "the", "unit", "to", "it", "." ]

[ "func", "(", "p", "placementData", ")", "placementType", "(", ")", "placementType", "{", "if", "p", ".", "containerType", "!=", "\"", "\"", "{", "return", "containerPlacement", "\n", "}", "\n", "if", "p", ".", "directive", "!=", "\"", "\"", "{", "return", "directivePlacement", "\n", "}", "\n", "return", "machinePlacement", "\n", "}" ]

[ "placementType", "returns", "the", "type", "of", "placement", "that", "this", "data", "represents", "." ]

[ "func", "(", "st", "*", "State", ")", "addMachineWithPlacement", "(", "unit", "*", "Unit", ",", "data", "*", "placementData", ")", "(", "*", "Machine", ",", "error", ")", "{", "unitCons", ",", "err", ":=", "unit", ".", "Constraints", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Create any new machine marked as dirty so that", "// nothing else will grab it before we assign the unit to it.", "// TODO(natefinch) fix this when we put assignment in the same", "// transaction as adding a machine. See bug", "// https://launchpad.net/bugs/1506994", "mId", ":=", "data", ".", "machineId", "\n", "var", "machine", "*", "Machine", "\n", "if", "data", ".", "machineId", "!=", "\"", "\"", "{", "machine", ",", "err", "=", "st", ".", "Machine", "(", "mId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Check if an upgrade-series lock is present for the requested", "// machine or its parent.", "// If one exists, return an error to prevent deployment.", "locked", ",", "err", ":=", "machine", ".", "IsLockedForSeriesUpgrade", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "locked", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "mId", ")", "\n", "}", "\n", "locked", ",", "err", "=", "machine", ".", "IsParentLockedForSeriesUpgrade", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "locked", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "mId", ")", "\n", "}", "\n", "}", "\n\n", "switch", "data", ".", "placementType", "(", ")", "{", "case", "containerPlacement", ":", "// If a container is to be used, create it.", "template", ":=", "MachineTemplate", "{", "Series", ":", "unit", ".", "Series", "(", ")", ",", "Jobs", ":", "[", "]", "MachineJob", "{", "JobHostUnits", "}", ",", "Dirty", ":", "true", ",", "Constraints", ":", "*", "unitCons", ",", "}", "\n", "if", "mId", "!=", "\"", "\"", "{", "return", "st", ".", "AddMachineInsideMachine", "(", "template", ",", "mId", ",", "data", ".", "containerType", ")", "\n", "}", "\n", "return", "st", ".", "AddMachineInsideNewMachine", "(", "template", ",", "template", ",", "data", ".", "containerType", ")", "\n", "case", "directivePlacement", ":", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ",", "unit", ".", "Name", "(", ")", ")", "\n", "default", ":", "return", "machine", ",", "nil", "\n", "}", "\n", "}" ]

[ "addMachineWithPlacement", "finds", "a", "machine", "that", "matches", "the", "given", "placement", "directive", "for", "the", "given", "unit", "." ]

[ "func", "(", "st", "*", "State", ")", "Application", "(", "name", "string", ")", "(", "_", "*", "Application", ",", "err", "error", ")", "{", "applications", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "applicationsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "if", "!", "names", ".", "IsValidApplication", "(", "name", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "sdoc", ":=", "&", "applicationDoc", "{", "}", "\n", "err", "=", "applications", ".", "FindId", "(", "name", ")", ".", "One", "(", "sdoc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "return", "newApplication", "(", "st", ",", "sdoc", ")", ",", "nil", "\n", "}" ]

[ "Application", "returns", "a", "application", "state", "by", "name", "." ]

[ "func", "(", "st", "*", "State", ")", "AllApplications", "(", ")", "(", "applications", "[", "]", "*", "Application", ",", "err", "error", ")", "{", "applicationsCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "applicationsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "sdocs", ":=", "[", "]", "applicationDoc", "{", "}", "\n", "err", "=", "applicationsCollection", ".", "Find", "(", "bson", ".", "D", "{", "}", ")", ".", "All", "(", "&", "sdocs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "v", ":=", "range", "sdocs", "{", "applications", "=", "append", "(", "applications", ",", "newApplication", "(", "st", ",", "&", "v", ")", ")", "\n", "}", "\n", "return", "applications", ",", "nil", "\n", "}" ]

[ "AllApplications", "returns", "all", "deployed", "applications", "in", "the", "model", "." ]

[ "func", "(", "st", "*", "State", ")", "endpoints", "(", "name", "string", ",", "filter", "func", "(", "ep", "Endpoint", ")", "bool", ")", "(", "[", "]", "Endpoint", ",", "error", ")", "{", "var", "appName", ",", "relName", "string", "\n", "if", "i", ":=", "strings", ".", "Index", "(", "name", ",", "\"", "\"", ")", ";", "i", "==", "-", "1", "{", "appName", "=", "name", "\n", "}", "else", "if", "i", "!=", "0", "&&", "i", "!=", "len", "(", "name", ")", "-", "1", "{", "appName", "=", "name", "[", ":", "i", "]", "\n", "relName", "=", "name", "[", "i", "+", "1", ":", "]", "\n", "}", "else", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "app", ",", "err", ":=", "applicationByName", "(", "st", ",", "appName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "eps", ":=", "[", "]", "Endpoint", "{", "}", "\n", "if", "relName", "!=", "\"", "\"", "{", "ep", ",", "err", ":=", "app", ".", "Endpoint", "(", "relName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "eps", "=", "append", "(", "eps", ",", "ep", ")", "\n", "}", "else", "{", "eps", ",", "err", "=", "app", ".", "Endpoints", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "final", ":=", "[", "]", "Endpoint", "{", "}", "\n", "for", "_", ",", "ep", ":=", "range", "eps", "{", "if", "filter", "(", "ep", ")", "{", "final", "=", "append", "(", "final", ",", "ep", ")", "\n", "}", "\n", "}", "\n", "return", "final", ",", "nil", "\n", "}" ]

[ "endpoints", "returns", "all", "endpoints", "that", "could", "be", "intended", "by", "the", "supplied", "endpoint", "name", "and", "which", "cause", "the", "filter", "param", "to", "return", "true", "." ]

[ "func", "(", "st", "*", "State", ")", "EndpointsRelation", "(", "endpoints", "...", "Endpoint", ")", "(", "*", "Relation", ",", "error", ")", "{", "return", "st", ".", "KeyRelation", "(", "relationKey", "(", "endpoints", ")", ")", "\n", "}" ]

[ "EndpointsRelation", "returns", "the", "existing", "relation", "with", "the", "given", "endpoints", "." ]

[ "func", "(", "st", "*", "State", ")", "Relation", "(", "id", "int", ")", "(", "*", "Relation", ",", "error", ")", "{", "relations", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "relationsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "doc", ":=", "relationDoc", "{", "}", "\n", "err", ":=", "relations", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "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", "return", "newRelation", "(", "st", ",", "&", "doc", ")", ",", "nil", "\n", "}" ]

[ "Relation", "returns", "the", "existing", "relation", "with", "the", "given", "id", "." ]

[ "func", "(", "st", "*", "State", ")", "AllRelations", "(", ")", "(", "relations", "[", "]", "*", "Relation", ",", "err", "error", ")", "{", "relationsCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "relationsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "docs", ":=", "relationDocSlice", "{", "}", "\n", "err", "=", "relationsCollection", ".", "Find", "(", "nil", ")", ".", "All", "(", "&", "docs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "docs", ")", "\n", "for", "_", ",", "v", ":=", "range", "docs", "{", "relations", "=", "append", "(", "relations", ",", "newRelation", "(", "st", ",", "&", "v", ")", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "AllRelations", "returns", "all", "relations", "in", "the", "model", "ordered", "by", "id", "." ]

[ "func", "(", "st", "*", "State", ")", "Unit", "(", "name", "string", ")", "(", "*", "Unit", ",", "error", ")", "{", "if", "!", "names", ".", "IsValidUnit", "(", "name", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "units", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "unitsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "doc", ":=", "unitDoc", "{", "}", "\n", "err", ":=", "units", ".", "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", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "newUnit", "(", "st", ",", "model", ".", "Type", "(", ")", ",", "&", "doc", ")", ",", "nil", "\n", "}" ]

[ "Unit", "returns", "a", "unit", "by", "name", "." ]

[ "func", "(", "st", "*", "State", ")", "UnitsFor", "(", "machineId", "string", ")", "(", "[", "]", "*", "Unit", ",", "error", ")", "{", "if", "!", "names", ".", "IsValidMachine", "(", "machineId", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "machineId", ")", "\n", "}", "\n", "m", ":=", "&", "Machine", "{", "st", ":", "st", ",", "doc", ":", "machineDoc", "{", "Id", ":", "machineId", ",", "}", ",", "}", "\n", "return", "m", ".", "Units", "(", ")", "\n", "}" ]

[ "UnitsFor", "returns", "the", "units", "placed", "in", "the", "given", "machine", "id", "." ]

[ "func", "(", "st", "*", "State", ")", "UnitsInError", "(", ")", "(", "[", "]", "*", "Unit", ",", "error", ")", "{", "// First, find the agents in error state.", "agentGlobalKeys", ",", "err", ":=", "getEntityKeysForStatus", "(", "st", ",", "\"", "\"", ",", "status", ".", "Error", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Extract the unit names.", "unitNames", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "agentGlobalKeys", ")", ")", "\n", "for", "i", ",", "key", ":=", "range", "agentGlobalKeys", "{", "// agent key prefix is \"u#\"", "if", "!", "strings", ".", "HasPrefix", "(", "key", ",", "\"", "\"", ")", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "unitNames", "[", "i", "]", "=", "key", "[", "2", ":", "]", "\n", "}", "\n\n", "// Query the units with the names of units in error.", "units", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "unitsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "docs", "[", "]", "unitDoc", "\n", "err", "=", "units", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "unitNames", "}", "}", "}", "}", ")", ".", "All", "(", "&", "docs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "result", ":=", "make", "(", "[", "]", "*", "Unit", ",", "len", "(", "docs", ")", ")", "\n", "for", "i", ",", "doc", ":=", "range", "docs", "{", "result", "[", "i", "]", "=", "&", "Unit", "{", "st", ":", "st", ",", "doc", ":", "doc", ",", "modelType", ":", "model", ".", "Type", "(", ")", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "UnitsInError", "returns", "the", "units", "which", "have", "an", "agent", "status", "of", "Error", "." ]

[ "func", "(", "st", "*", "State", ")", "AssignUnit", "(", "u", "*", "Unit", ",", "policy", "AssignmentPolicy", ")", "(", "err", "error", ")", "{", "if", "!", "u", ".", "IsPrincipal", "(", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "u", ")", "\n", "}", "\n", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "u", ")", "\n", "var", "m", "*", "Machine", "\n", "switch", "policy", "{", "case", "AssignLocal", ":", "m", ",", "err", "=", "st", ".", "Machine", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "u", ".", "AssignToMachine", "(", "m", ")", "\n", "case", "AssignClean", ":", "if", "_", ",", "err", "=", "u", ".", "AssignToCleanMachine", "(", ")", ";", "errors", ".", "Cause", "(", "err", ")", "!=", "noCleanMachines", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "u", ".", "AssignToNewMachineOrContainer", "(", ")", "\n", "case", "AssignCleanEmpty", ":", "if", "_", ",", "err", "=", "u", ".", "AssignToCleanEmptyMachine", "(", ")", ";", "errors", ".", "Cause", "(", "err", ")", "!=", "noCleanMachines", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "u", ".", "AssignToNewMachineOrContainer", "(", ")", "\n", "case", "AssignNew", ":", "return", "errors", ".", "Trace", "(", "u", ".", "AssignToNewMachine", "(", ")", ")", "\n", "}", "\n", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "policy", ")", "\n", "}" ]

[ "AssignUnit", "places", "the", "unit", "on", "a", "machine", ".", "Depending", "on", "the", "policy", "and", "the", "state", "of", "the", "model", "this", "may", "lead", "to", "new", "instances", "being", "launched", "within", "the", "model", "." ]

[ "func", "(", "st", "*", "State", ")", "StartSync", "(", ")", "{", "if", "advanceable", ",", "ok", ":=", "st", ".", "clock", "(", ")", ".", "(", "hasAdvance", ")", ";", "ok", "{", "// The amount of time we advance here just needs to be more", "// than 10ms as that is the minimum time the txnwatcher", "// is waiting on, however one second is more human noticeable.", "// The state testing StateSuite type changes the polling interval", "// of the pool's txnwatcher to be one second.", "advanceable", ".", "Advance", "(", "time", ".", "Second", ")", "\n", "}", "\n", "if", "syncable", ",", "ok", ":=", "st", ".", "workers", ".", "txnLogWatcher", "(", ")", ".", "(", "hasStartSync", ")", ";", "ok", "{", "syncable", ".", "StartSync", "(", ")", "\n", "}", "\n", "st", ".", "workers", ".", "pingBatcherWorker", "(", ")", ".", "Sync", "(", ")", "\n", "st", ".", "workers", ".", "presenceWatcher", "(", ")", ".", "Sync", "(", ")", "\n", "}" ]

[ "StartSync", "forces", "watchers", "to", "resynchronize", "their", "state", "with", "the", "database", "immediately", ".", "This", "will", "happen", "periodically", "automatically", ".", "This", "method", "is", "called", "only", "from", "tests", "." ]

[ "func", "(", "st", "*", "State", ")", "SetAdminMongoPassword", "(", "password", "string", ")", "error", "{", "err", ":=", "mongo", ".", "SetAdminMongoPassword", "(", "st", ".", "session", ",", "mongo", ".", "AdminUser", ",", "password", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "SetAdminMongoPassword", "sets", "the", "administrative", "password", "to", "access", "the", "state", ".", "If", "the", "password", "is", "non", "-", "empty", "all", "subsequent", "attempts", "to", "access", "the", "state", "must", "be", "authorized", ";", "otherwise", "no", "authorization", "is", "required", "." ]

[ "func", "(", "st", "*", "State", ")", "ControllerInfo", "(", ")", "(", "*", "ControllerInfo", ",", "error", ")", "{", "session", ":=", "st", ".", "session", ".", "Copy", "(", ")", "\n", "defer", "session", ".", "Close", "(", ")", "\n", "return", "readRawControllerInfo", "(", "session", ")", "\n", "}" ]

[ "ControllerInfo", "returns", "information", "about", "the", "currently", "configured", "controller", "machines", "." ]

[ "func", "readRawControllerInfo", "(", "session", "*", "mgo", ".", "Session", ")", "(", "*", "ControllerInfo", ",", "error", ")", "{", "db", ":=", "session", ".", "DB", "(", "jujuDB", ")", "\n", "controllers", ":=", "db", ".", "C", "(", "controllersC", ")", "\n\n", "var", "doc", "controllersDoc", "\n", "err", ":=", "controllers", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "modelGlobalKey", "}", "}", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "ControllerInfo", "{", "CloudName", ":", "doc", ".", "CloudName", ",", "ModelTag", ":", "names", ".", "NewModelTag", "(", "doc", ".", "ModelUUID", ")", ",", "MachineIds", ":", "doc", ".", "MachineIds", ",", "}", ",", "nil", "\n", "}" ]

[ "readRawControllerInfo", "reads", "ControllerInfo", "direct", "from", "the", "supplied", "session", "falling", "back", "to", "the", "bootstrap", "model", "document", "to", "extract", "the", "UUID", "when", "required", "." ]

[ "func", "(", "st", "*", "State", ")", "StateServingInfo", "(", ")", "(", "StateServingInfo", ",", "error", ")", "{", "controllers", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "controllersC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "info", "StateServingInfo", "\n", "err", ":=", "controllers", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "stateServingInfoKey", "}", "}", ")", ".", "One", "(", "&", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "info", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "info", ".", "StatePort", "==", "0", "{", "return", "StateServingInfo", "{", "}", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "info", ",", "nil", "\n", "}" ]

[ "StateServingInfo", "returns", "information", "for", "running", "a", "controller", "machine" ]

[ "func", "(", "st", "*", "State", ")", "SetStateServingInfo", "(", "info", "StateServingInfo", ")", "error", "{", "if", "info", ".", "StatePort", "==", "0", "||", "info", ".", "APIPort", "==", "0", "||", "info", ".", "Cert", "==", "\"", "\"", "||", "info", ".", "PrivateKey", "==", "\"", "\"", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "info", ".", "CAPrivateKey", "==", "\"", "\"", "{", "// No CA certificate key means we can't generate new controller", "// certificates when needed to add to the certificate SANs.", "// Older Juju deployments discard the key because no one realised", "// the certificate was flawed, so at best we can log a warning", "// until an upgrade process is written.", "logger", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "\n", "ops", ":=", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "controllersC", ",", "Id", ":", "stateServingInfoKey", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "info", "}", "}", ",", "}", "}", "\n", "if", "err", ":=", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetStateServingInfo", "stores", "information", "needed", "for", "running", "a", "controller" ]