Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "Manifold", "(", "config", "ManifoldConfig", ")", "dependency", ".", "Manifold", "{", "typedConfig", ":=", "engine", ".", "AgentAPIManifoldConfig", "{", "AgentName", ":", "config", ".", "AgentName", ",", "APICallerName", ":", "config", ".", "APICallerName", ",", "}", "\n", "manifold", ":=", "engine", ".", "AgentAPIManifold", "(", "typedConfig", ",", "config", ".", "start", ")", "\n", "manifold", ".", "Output", "=", "config", ".", "output", "\n", "return", "manifold", "\n", "}" ]

[ "Manifold", "returns", "a", "dependency", "manifold", "that", "runs", "a", "hook", "retry", "strategy", "worker", "using", "the", "agent", "name", "and", "the", "api", "connection", "resources", "named", "in", "the", "supplied", "config", "." ]

[ "func", "IsFatal", "(", "err", "error", ")", "bool", "{", "err", "=", "errors", ".", "Cause", "(", "err", ")", "\n", "switch", "err", "{", "case", "jworker", ".", "ErrTerminateAgent", ",", "jworker", ".", "ErrRebootMachine", ",", "jworker", ".", "ErrShutdownMachine", ",", "jworker", ".", "ErrRestartAgent", ":", "return", "true", "\n", "}", "\n\n", "if", "isUpgraded", "(", "err", ")", "{", "return", "true", "\n", "}", "\n", "_", ",", "ok", ":=", "err", ".", "(", "*", "FatalError", ")", "\n", "return", "ok", "\n", "}" ]

[ "IsFatal", "determines", "if", "an", "error", "is", "fatal", "to", "the", "process", "." ]

[ "func", "MoreImportantError", "(", "err0", ",", "err1", "error", ")", "error", "{", "if", "importance", "(", "err0", ")", ">", "importance", "(", "err1", ")", "{", "return", "err0", "\n", "}", "\n", "return", "err1", "\n", "}" ]

[ "MoreImportantError", "returns", "the", "most", "important", "error" ]

[ "func", "AgentDone", "(", "logger", "loggo", ".", "Logger", ",", "err", "error", ")", "error", "{", "err", "=", "errors", ".", "Cause", "(", "err", ")", "\n", "switch", "err", "{", "case", "jworker", ".", "ErrTerminateAgent", ",", "jworker", ".", "ErrRebootMachine", ",", "jworker", ".", "ErrShutdownMachine", ":", "// These errors are swallowed here because we want to exit", "// the agent process without error, to avoid the init system", "// restarting us.", "err", "=", "nil", "\n", "}", "\n", "if", "ug", ",", "ok", ":=", "err", ".", "(", "*", "upgrader", ".", "UpgradeReadyError", ")", ";", "ok", "{", "if", "err", ":=", "ug", ".", "ChangeAgentTools", "(", ")", ";", "err", "!=", "nil", "{", "// Return and let the init system deal with the restart.", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "logger", ".", "Infof", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "if", "err", "==", "jworker", ".", "ErrRestartAgent", "{", "logger", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "AgentDone", "processes", "the", "error", "returned", "by", "an", "exiting", "agent", "." ]

[ "func", "ConnectionIsFatal", "(", "logger", "loggo", ".", "Logger", ",", "conns", "...", "Breakable", ")", "func", "(", "err", "error", ")", "bool", "{", "return", "func", "(", "err", "error", ")", "bool", "{", "if", "IsFatal", "(", "err", ")", "{", "return", "true", "\n", "}", "\n", "for", "_", ",", "conn", ":=", "range", "conns", "{", "if", "ConnectionIsDead", "(", "logger", ",", "conn", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "}" ]

[ "ConnectionIsFatal", "returns", "a", "function", "suitable", "for", "passing", "as", "the", "isFatal", "argument", "to", "worker", ".", "NewRunner", "that", "diagnoses", "an", "error", "as", "fatal", "if", "the", "connection", "has", "failed", "or", "if", "the", "error", "is", "otherwise", "fatal", "." ]

[ "func", "NewEnsureServerParams", "(", "agentConfig", "agent", ".", "Config", ")", "(", "mongo", ".", "EnsureServerParams", ",", "error", ")", "{", "// If oplog size is specified in the agent configuration, use that.", "// Otherwise leave the default zero value to indicate to EnsureServer", "// that it should calculate the size.", "var", "oplogSize", "int", "\n", "if", "oplogSizeString", ":=", "agentConfig", ".", "Value", "(", "agent", ".", "MongoOplogSize", ")", ";", "oplogSizeString", "!=", "\"", "\"", "{", "var", "err", "error", "\n", "if", "oplogSize", ",", "err", "=", "strconv", ".", "Atoi", "(", "oplogSizeString", ")", ";", "err", "!=", "nil", "{", "return", "mongo", ".", "EnsureServerParams", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "oplogSizeString", ")", "\n", "}", "\n", "}", "\n\n", "// If numa ctl preference is specified in the agent configuration, use that.", "// Otherwise leave the default false value to indicate to EnsureServer", "// that numactl should not be used.", "var", "numaCtlPolicy", "bool", "\n", "if", "numaCtlString", ":=", "agentConfig", ".", "Value", "(", "agent", ".", "NUMACtlPreference", ")", ";", "numaCtlString", "!=", "\"", "\"", "{", "var", "err", "error", "\n", "if", "numaCtlPolicy", ",", "err", "=", "strconv", ".", "ParseBool", "(", "numaCtlString", ")", ";", "err", "!=", "nil", "{", "return", "mongo", ".", "EnsureServerParams", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "numaCtlString", ")", "\n", "}", "\n", "}", "\n\n", "si", ",", "ok", ":=", "agentConfig", ".", "StateServingInfo", "(", ")", "\n", "if", "!", "ok", "{", "return", "mongo", ".", "EnsureServerParams", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "params", ":=", "mongo", ".", "EnsureServerParams", "{", "APIPort", ":", "si", ".", "APIPort", ",", "StatePort", ":", "si", ".", "StatePort", ",", "Cert", ":", "si", ".", "Cert", ",", "PrivateKey", ":", "si", ".", "PrivateKey", ",", "CAPrivateKey", ":", "si", ".", "CAPrivateKey", ",", "SharedSecret", ":", "si", ".", "SharedSecret", ",", "SystemIdentity", ":", "si", ".", "SystemIdentity", ",", "DataDir", ":", "agentConfig", ".", "DataDir", "(", ")", ",", "OplogSize", ":", "oplogSize", ",", "SetNUMAControlPolicy", ":", "numaCtlPolicy", ",", "MemoryProfile", ":", "agentConfig", ".", "MongoMemoryProfile", "(", ")", ",", "}", "\n", "return", "params", ",", "nil", "\n", "}" ]

[ "NewEnsureServerParams", "creates", "an", "EnsureServerParams", "from", "an", "agent", "configuration", "." ]

[ "func", "Open", "(", "conn", "base", ".", "StreamConnector", ",", "path", "string", ",", "cfg", "interface", "{", "}", ")", "(", "base", ".", "Stream", ",", "error", ")", "{", "attrs", ",", "err", ":=", "query", ".", "Values", "(", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "stream", ",", "err", ":=", "conn", ".", "ConnectStream", "(", "path", ",", "attrs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "return", "stream", ",", "nil", "\n", "}" ]

[ "Open", "opens", "a", "streaming", "connection", "to", "the", "endpoint", "path", "that", "conforms", "to", "the", "provided", "config", "." ]

[ "func", "NewAPI", "(", "caller", "base", ".", "APICaller", ",", "newWatcher", "NewWatcherFunc", ")", "*", "API", "{", "return", "&", "API", "{", "caller", ":", "base", ".", "NewFacadeCaller", "(", "caller", ",", "\"", "\"", ")", ",", "newWatcher", ":", "newWatcher", ",", "}", "\n", "}" ]

[ "NewAPI", "returns", "a", "new", "API", "using", "the", "supplied", "caller", "." ]

[ "func", "(", "api", "*", "API", ")", "Watch", "(", ")", "(", "watcher", ".", "StringsWatcher", ",", "error", ")", "{", "var", "result", "params", ".", "StringsWatchResult", "\n", "err", ":=", "api", ".", "caller", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "result", ".", "Error", ")", "\n", "}", "\n", "w", ":=", "api", ".", "newWatcher", "(", "api", ".", "caller", ".", "RawAPICaller", "(", ")", ",", "result", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "Watch", "returns", "a", "StringsWatcher", "that", "delivers", "the", "names", "of", "applications", "that", "may", "need", "to", "be", "rescaled", "." ]

[ "func", "(", "api", "*", "API", ")", "Rescale", "(", "applications", "[", "]", "string", ")", "error", "{", "args", ":=", "params", ".", "Entities", "{", "Entities", ":", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "applications", ")", ")", ",", "}", "\n", "for", "i", ",", "application", ":=", "range", "applications", "{", "if", "!", "names", ".", "IsValidApplication", "(", "application", ")", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "application", ")", "\n", "}", "\n", "tag", ":=", "names", ".", "NewApplicationTag", "(", "application", ")", "\n", "args", ".", "Entities", "[", "i", "]", ".", "Tag", "=", "tag", ".", "String", "(", ")", "\n", "}", "\n", "var", "results", "params", ".", "ErrorResults", "\n", "err", ":=", "api", ".", "caller", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "result", ":=", "range", "results", ".", "Results", "{", "if", "result", ".", "Error", "!=", "nil", "{", "if", "err", "==", "nil", "{", "err", "=", "result", ".", "Error", "\n", "}", "else", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "Rescale", "requests", "that", "all", "supplied", "application", "names", "be", "rescaled", "to", "their", "minimum", "configured", "sizes", ".", "It", "returns", "the", "first", "error", "it", "encounters", "." ]

[ "func", "ZoneIndependentError", "(", "err", "error", ")", "error", "{", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "wrapped", ":=", "errors", ".", "Wrap", "(", "err", ",", "zoneIndependentError", "{", "err", "}", ")", "\n", "wrapped", ".", "(", "*", "errors", ".", "Err", ")", ".", "SetLocation", "(", "1", ")", "\n", "return", "wrapped", "\n", "}" ]

[ "ZoneIndependentError", "wraps", "the", "given", "error", "such", "that", "it", "satisfies", "environs", ".", "IsAvailabilityZoneIndependent", "." ]

[ "func", "MaybeHandleCredentialError", "(", "isAuthError", "func", "(", "error", ")", "bool", ",", "err", "error", ",", "ctx", "context", ".", "ProviderCallContext", ")", "bool", "{", "denied", ":=", "isAuthError", "(", "errors", ".", "Cause", "(", "err", ")", ")", "\n", "if", "ctx", "!=", "nil", "&&", "denied", "{", "invalidateErr", ":=", "ctx", ".", "InvalidateCredential", "(", "\"", "\"", ")", "\n", "if", "invalidateErr", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "invalidateErr", ")", "\n", "}", "\n", "}", "\n", "return", "denied", "\n", "}" ]

[ "MaybeHandleCredentialError", "determines", "if", "a", "given", "error", "relates", "to", "an", "invalid", "credential", ".", "If", "it", "is", "the", "credential", "is", "invalidated", "and", "the", "return", "bool", "is", "true", "." ]

[ "func", "HandleCredentialError", "(", "isAuthError", "func", "(", "error", ")", "bool", ",", "err", "error", ",", "ctx", "context", ".", "ProviderCallContext", ")", "{", "MaybeHandleCredentialError", "(", "isAuthError", ",", "err", ",", "ctx", ")", "\n", "}" ]

[ "HandleCredentialError", "determines", "if", "a", "given", "error", "relates", "to", "an", "invalid", "credential", "." ]

[ "func", "(", "p", "kubernetesEnvironProvider", ")", "Open", "(", "args", "environs", ".", "OpenParams", ")", "(", "caas", ".", "Broker", ",", "error", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "args", ".", "Config", ".", "Name", "(", ")", ")", "\n", "if", "err", ":=", "p", ".", "validateCloudSpec", "(", "args", ".", "Cloud", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "k8sRestConfig", ",", "err", ":=", "cloudSpecToK8sRestConfig", "(", "args", ".", "Cloud", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "broker", ",", "err", ":=", "NewK8sBroker", "(", "args", ".", "ControllerUUID", ",", "k8sRestConfig", ",", "args", ".", "Config", ",", "newK8sClient", ",", "newKubernetesWatcher", ",", "jujuclock", ".", "WallClock", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "controllerCorelation", "(", "broker", ")", "\n", "}" ]

[ "Open", "is", "part", "of", "the", "ContainerEnvironProvider", "interface", "." ]

[ "func", "(", "kubernetesEnvironProvider", ")", "ParsePodSpec", "(", "in", "string", ")", "(", "*", "caas", ".", "PodSpec", ",", "error", ")", "{", "spec", ",", "err", ":=", "parseK8sPodSpec", "(", "in", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "spec", ",", "spec", ".", "Validate", "(", ")", "\n", "}" ]

[ "ParsePodSpec", "is", "part", "of", "the", "ContainerEnvironProvider", "interface", "." ]

[ "func", "(", "r", "*", "Recorder", ")", "AddRequest", "(", "m", "RequestArgs", ")", "error", "{", "return", "errors", ".", "Trace", "(", "r", ".", "log", ".", "AddRequest", "(", "Request", "{", "ConversationID", ":", "r", ".", "callID", ",", "ConnectionID", ":", "r", ".", "connectionID", ",", "RequestID", ":", "m", ".", "RequestID", ",", "When", ":", "r", ".", "clock", ".", "Now", "(", ")", ".", "Format", "(", "time", ".", "RFC3339", ")", ",", "Facade", ":", "m", ".", "Facade", ",", "Method", ":", "m", ".", "Method", ",", "Version", ":", "m", ".", "Version", ",", "Args", ":", "m", ".", "Args", ",", "}", ")", ")", "\n", "}" ]

[ "AddRequest", "records", "a", "method", "call", "to", "the", "API", "." ]

[ "func", "(", "r", "*", "Recorder", ")", "AddResponse", "(", "m", "ResponseErrorsArgs", ")", "error", "{", "return", "errors", ".", "Trace", "(", "r", ".", "log", ".", "AddResponse", "(", "ResponseErrors", "{", "ConversationID", ":", "r", ".", "callID", ",", "ConnectionID", ":", "r", ".", "connectionID", ",", "RequestID", ":", "m", ".", "RequestID", ",", "When", ":", "r", ".", "clock", ".", "Now", "(", ")", ".", "Format", "(", "time", ".", "RFC3339", ")", ",", "Errors", ":", "m", ".", "Errors", ",", "}", ")", ")", "\n", "}" ]

[ "AddResponse", "records", "the", "result", "of", "a", "method", "call", "to", "the", "API", "." ]

[ "func", "newConversationID", "(", ")", "string", "{", "buf", ":=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n", "rand", ".", "Read", "(", "buf", ")", "// Can't fail", "\n", "return", "hex", ".", "EncodeToString", "(", "buf", ")", "\n", "}" ]

[ "newConversationID", "generates", "a", "random", "64bit", "integer", "as", "hex", "-", "this", "will", "be", "used", "to", "link", "the", "requests", "and", "responses", "with", "the", "command", "the", "user", "issued", ".", "We", "don", "t", "use", "the", "API", "server", "s", "connection", "ID", "here", "because", "that", "starts", "from", "0", "and", "increments", "so", "it", "resets", "when", "the", "API", "server", "is", "restarted", ".", "The", "conversation", "ID", "needs", "to", "be", "unique", "across", "restarts", "otherwise", "we", "d", "attribute", "requests", "to", "the", "wrong", "conversation", "." ]

[ "func", "(", "a", "*", "auditLogFile", ")", "AddConversation", "(", "c", "Conversation", ")", "error", "{", "return", "errors", ".", "Trace", "(", "a", ".", "addRecord", "(", "Record", "{", "Conversation", ":", "&", "c", "}", ")", ")", "\n", "}" ]

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

[ "func", "(", "a", "*", "auditLogFile", ")", "AddRequest", "(", "m", "Request", ")", "error", "{", "return", "errors", ".", "Trace", "(", "a", ".", "addRecord", "(", "Record", "{", "Request", ":", "&", "m", "}", ")", ")", "\n\n", "}" ]

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

[ "func", "(", "a", "*", "auditLogFile", ")", "AddResponse", "(", "m", "ResponseErrors", ")", "error", "{", "return", "errors", ".", "Trace", "(", "a", ".", "addRecord", "(", "Record", "{", "Errors", ":", "&", "m", "}", ")", ")", "\n", "}" ]

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

[ "func", "(", "c", "UnitFacadeClient", ")", "Track", "(", "payloads", "...", "payload", ".", "Payload", ")", "(", "[", "]", "payload", ".", "Result", ",", "error", ")", "{", "args", ":=", "internal", ".", "Payloads2TrackArgs", "(", "payloads", ")", "\n\n", "var", "rs", "params", ".", "PayloadResults", "\n", "if", "err", ":=", "c", ".", "FacadeCall", "(", "\"", "\"", ",", "&", "args", ",", "&", "rs", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "api2results", "(", "rs", ")", "\n", "}" ]

[ "Track", "calls", "the", "Track", "API", "server", "method", "." ]

[ "func", "(", "c", "UnitFacadeClient", ")", "List", "(", "fullIDs", "...", "string", ")", "(", "[", "]", "payload", ".", "Result", ",", "error", ")", "{", "var", "ids", "[", "]", "string", "\n", "if", "len", "(", "fullIDs", ")", ">", "0", "{", "actual", ",", "err", ":=", "c", ".", "lookUp", "(", "fullIDs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ids", "=", "actual", "\n", "}", "\n", "args", ":=", "internal", ".", "IDs2ListArgs", "(", "ids", ")", "\n\n", "var", "rs", "params", ".", "PayloadResults", "\n", "if", "err", ":=", "c", ".", "FacadeCall", "(", "\"", "\"", ",", "&", "args", ",", "&", "rs", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "api2results", "(", "rs", ")", "\n", "}" ]

[ "List", "calls", "the", "List", "API", "server", "method", "." ]

[ "func", "(", "c", "UnitFacadeClient", ")", "LookUp", "(", "fullIDs", "...", "string", ")", "(", "[", "]", "payload", ".", "Result", ",", "error", ")", "{", "if", "len", "(", "fullIDs", ")", "==", "0", "{", "// Unlike List(), LookUp doesn't fall back to looking up all IDs.", "return", "nil", ",", "nil", "\n", "}", "\n", "args", ":=", "internal", ".", "FullIDs2LookUpArgs", "(", "fullIDs", ")", "\n\n", "var", "rs", "params", ".", "PayloadResults", "\n", "if", "err", ":=", "c", ".", "FacadeCall", "(", "\"", "\"", ",", "&", "args", ",", "&", "rs", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "api2results", "(", "rs", ")", "\n", "}" ]

[ "LookUp", "calls", "the", "LookUp", "API", "server", "method", "." ]

[ "func", "(", "c", "UnitFacadeClient", ")", "SetStatus", "(", "status", "string", ",", "fullIDs", "...", "string", ")", "(", "[", "]", "payload", ".", "Result", ",", "error", ")", "{", "ids", ",", "err", ":=", "c", ".", "lookUp", "(", "fullIDs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "args", ":=", "internal", ".", "IDs2SetStatusArgs", "(", "ids", ",", "status", ")", "\n\n", "var", "rs", "params", ".", "PayloadResults", "\n", "if", "err", ":=", "c", ".", "FacadeCall", "(", "\"", "\"", ",", "&", "args", ",", "&", "rs", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "api2results", "(", "rs", ")", "\n", "}" ]

[ "SetStatus", "calls", "the", "SetStatus", "API", "server", "method", "." ]

[ "func", "(", "c", "UnitFacadeClient", ")", "Untrack", "(", "fullIDs", "...", "string", ")", "(", "[", "]", "payload", ".", "Result", ",", "error", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "fullIDs", ")", "\n\n", "ids", ",", "err", ":=", "c", ".", "lookUp", "(", "fullIDs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "args", ":=", "internal", ".", "IDs2UntrackArgs", "(", "ids", ")", "\n\n", "var", "rs", "params", ".", "PayloadResults", "\n", "if", "err", ":=", "c", ".", "FacadeCall", "(", "\"", "\"", ",", "&", "args", ",", "&", "rs", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "api2results", "(", "rs", ")", "\n", "}" ]

[ "Untrack", "calls", "the", "Untrack", "API", "server", "method", "." ]

[ "func", "NewMockLeadershipPinningBackend", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockLeadershipPinningBackend", "{", "mock", ":=", "&", "MockLeadershipPinningBackend", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockLeadershipPinningBackendMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "NewMockLeadershipMachine", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockLeadershipMachine", "{", "mock", ":=", "&", "MockLeadershipMachine", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockLeadershipMachineMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

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

[ "ApplicationNames", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockLeadershipMachineMockRecorder", ")", "ApplicationNames", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockLeadershipMachine", ")", "(", "nil", ")", ".", "ApplicationNames", ")", ")", "\n", "}" ]

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

[ "func", "NewMockCommandRunner", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockCommandRunner", "{", "mock", ":=", "&", "MockCommandRunner", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockCommandRunnerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockCommandRunner", ")", "RunCommands", "(", "arg0", "exec", ".", "RunParams", ")", "(", "*", "exec", ".", "ExecResponse", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "*", "exec", ".", "ExecResponse", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "RunCommands", "mocks", "base", "method" ]

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

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

[ "func", "Payload2api", "(", "p", "payload", ".", "FullPayloadInfo", ")", "params", ".", "Payload", "{", "labels", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "p", ".", "Labels", ")", ")", "\n", "copy", "(", "labels", ",", "p", ".", "Labels", ")", "\n\n", "var", "unitTag", "string", "\n", "if", "p", ".", "Unit", "!=", "\"", "\"", "{", "unitTag", "=", "names", ".", "NewUnitTag", "(", "p", ".", "Unit", ")", ".", "String", "(", ")", "\n", "}", "\n", "var", "machineTag", "string", "\n", "if", "p", ".", "Machine", "!=", "\"", "\"", "{", "machineTag", "=", "names", ".", "NewMachineTag", "(", "p", ".", "Machine", ")", ".", "String", "(", ")", "\n", "}", "\n\n", "return", "params", ".", "Payload", "{", "Class", ":", "p", ".", "Name", ",", "Type", ":", "p", ".", "Type", ",", "ID", ":", "p", ".", "ID", ",", "Status", ":", "p", ".", "Status", ",", "Labels", ":", "labels", ",", "Unit", ":", "unitTag", ",", "Machine", ":", "machineTag", ",", "}", "\n", "}" ]

[ "Payload2api", "converts", "a", "payload", ".", "FullPayloadInfo", "struct", "into", "a", "Payload", "struct", "." ]

[ "func", "API2Payload", "(", "apiInfo", "params", ".", "Payload", ")", "(", "payload", ".", "FullPayloadInfo", ",", "error", ")", "{", "labels", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "apiInfo", ".", "Labels", ")", ")", "\n", "copy", "(", "labels", ",", "apiInfo", ".", "Labels", ")", "\n\n", "var", "unit", ",", "machine", "string", "\n", "var", "empty", "payload", ".", "FullPayloadInfo", "\n", "if", "apiInfo", ".", "Unit", "!=", "\"", "\"", "{", "tag", ",", "err", ":=", "names", ".", "ParseUnitTag", "(", "apiInfo", ".", "Unit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "empty", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "unit", "=", "tag", ".", "Id", "(", ")", "\n", "}", "\n", "if", "apiInfo", ".", "Machine", "!=", "\"", "\"", "{", "tag", ",", "err", ":=", "names", ".", "ParseMachineTag", "(", "apiInfo", ".", "Machine", ")", "\n", "if", "err", "!=", "nil", "{", "return", "empty", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "machine", "=", "tag", ".", "Id", "(", ")", "\n", "}", "\n\n", "return", "payload", ".", "FullPayloadInfo", "{", "Payload", ":", "payload", ".", "Payload", "{", "PayloadClass", ":", "charm", ".", "PayloadClass", "{", "Name", ":", "apiInfo", ".", "Class", ",", "Type", ":", "apiInfo", ".", "Type", ",", "}", ",", "ID", ":", "apiInfo", ".", "ID", ",", "Status", ":", "apiInfo", ".", "Status", ",", "Labels", ":", "labels", ",", "Unit", ":", "unit", ",", "}", ",", "Machine", ":", "machine", ",", "}", ",", "nil", "\n", "}" ]

[ "API2Payload", "converts", "an", "API", "Payload", "info", "struct", "into", "a", "payload", ".", "FullPayloadInfo", "struct", "." ]

[ "func", "ListServices", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "// TODO(ericsnow) conn.ListUnits misses some inactive units, so we", "// would need conn.ListUnitFiles. Such a method has been requested.", "// (see https://github.com/coreos/go-systemd/issues/76). In the", "// meantime we use systemctl at the shell to list the services.", "// Once that is addressed upstream we can just call listServices here.", "names", ",", "err", ":=", "Cmdline", "{", "}", ".", "ListAll", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "names", ",", "nil", "\n", "}" ]

[ "ListServices", "returns", "the", "list", "of", "installed", "service", "names", "." ]

[ "func", "NewServiceWithDefaults", "(", "name", "string", ",", "conf", "common", ".", "Conf", ")", "(", "*", "Service", ",", "error", ")", "{", "svc", ",", "err", ":=", "NewService", "(", "name", ",", "conf", ",", "LibSystemdDir", ",", "NewDBusAPI", ",", "renderer", ".", "Join", "(", "paths", ".", "NixDataDir", ",", "\"", "\"", ")", ")", "\n", "return", "svc", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "NewServiceWithDefaults", "returns", "a", "new", "systemd", "service", "reference", "populated", "with", "sensible", "defaults", "." ]

[ "func", "NewService", "(", "name", "string", ",", "conf", "common", ".", "Conf", ",", "dataDir", "string", ",", "newDBus", "DBusAPIFactory", ",", "fallBackDirName", "string", ",", ")", "(", "*", "Service", ",", "error", ")", "{", "confName", ":=", "name", "+", "\"", "\"", "\n", "var", "volName", "string", "\n", "if", "conf", ".", "ExecStart", "!=", "\"", "\"", "{", "volName", "=", "renderer", ".", "VolumeName", "(", "common", ".", "Unquote", "(", "strings", ".", "Fields", "(", "conf", ".", "ExecStart", ")", "[", "0", "]", ")", ")", "\n", "}", "\n", "dirName", ":=", "volName", "+", "renderer", ".", "Join", "(", "dataDir", ",", "name", ")", "\n\n", "service", ":=", "&", "Service", "{", "Service", ":", "common", ".", "Service", "{", "Name", ":", "name", ",", "// Conf is set in setConf.", "}", ",", "ConfName", ":", "confName", ",", "UnitName", ":", "confName", ",", "DirName", ":", "dirName", ",", "FallBackDirName", ":", "fallBackDirName", ",", "newDBus", ":", "newDBus", ",", "}", "\n\n", "if", "err", ":=", "service", ".", "setConf", "(", "conf", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "service", ",", "nil", "\n", "}" ]

[ "NewService", "returns", "a", "new", "reference", "to", "an", "object", "that", "implements", "the", "Service", "interface", "for", "systemd", "." ]

[ "func", "(", "s", "*", "Service", ")", "Installed", "(", ")", "(", "bool", ",", "error", ")", "{", "names", ",", "err", ":=", "ListServices", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "s", ".", "errorf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "if", "name", "==", "s", ".", "Service", ".", "Name", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "Installed", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "Exists", "(", ")", "(", "bool", ",", "error", ")", "{", "if", "s", ".", "NoConf", "(", ")", "{", "return", "false", ",", "s", ".", "errorf", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "same", ",", "err", ":=", "s", ".", "check", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "same", ",", "nil", "\n", "}" ]

[ "Exists", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "Running", "(", ")", "(", "bool", ",", "error", ")", "{", "conn", ",", "err", ":=", "s", ".", "newConn", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "units", ",", "err", ":=", "conn", ".", "ListUnits", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "s", ".", "errorf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "for", "_", ",", "unit", ":=", "range", "units", "{", "if", "unit", ".", "Name", "==", "s", ".", "UnitName", "{", "running", ":=", "unit", ".", "LoadState", "==", "\"", "\"", "&&", "unit", ".", "ActiveState", "==", "\"", "\"", "\n", "return", "running", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "Running", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "Start", "(", ")", "error", "{", "err", ":=", "s", ".", "start", "(", ")", "\n", "if", "errors", ".", "IsAlreadyExists", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Start", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "Stop", "(", ")", "error", "{", "err", ":=", "s", ".", "stop", "(", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Stop", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "Remove", "(", ")", "error", "{", "err", ":=", "s", ".", "remove", "(", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Remove", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "Install", "(", ")", "error", "{", "if", "s", ".", "NoConf", "(", ")", "{", "return", "s", ".", "errorf", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "err", ":=", "s", ".", "install", "(", ")", "\n", "if", "errors", ".", "IsAlreadyExists", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Install", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "InstallCommands", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "s", ".", "NoConf", "(", ")", "{", "return", "nil", ",", "s", ".", "errorf", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "name", ":=", "s", ".", "Name", "(", ")", "\n", "dirname", ":=", "s", ".", "DirName", "\n\n", "data", ",", "err", ":=", "s", ".", "serialize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "cmdList", ":=", "[", "]", "string", "{", "cmds", ".", "mkdirs", "(", "dirname", ")", ",", "}", "\n", "if", "s", ".", "Script", "!=", "nil", "{", "scriptName", ":=", "renderer", ".", "Base", "(", "renderer", ".", "ScriptFilename", "(", "\"", "\"", ",", "\"", "\"", ")", ")", "\n", "cmdList", "=", "append", "(", "cmdList", ",", "[", "]", "string", "{", "// TODO(ericsnow) Use the renderer here.", "cmds", ".", "writeFile", "(", "scriptName", ",", "dirname", ",", "s", ".", "Script", ")", ",", "cmds", ".", "chmod", "(", "scriptName", ",", "dirname", ",", "0755", ")", ",", "}", "...", ")", "\n", "}", "\n", "cmdList", "=", "append", "(", "cmdList", ",", "[", "]", "string", "{", "cmds", ".", "writeConf", "(", "name", ",", "dirname", ",", "data", ")", ",", "cmds", ".", "link", "(", "name", ",", "dirname", ")", ",", "cmds", ".", "reload", "(", ")", ",", "cmds", ".", "enableLinked", "(", "name", ",", "dirname", ")", ",", "}", "...", ")", "\n", "return", "cmdList", ",", "nil", "\n", "}" ]

[ "InstallCommands", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "StartCommands", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "name", ":=", "s", ".", "Name", "(", ")", "\n", "cmdList", ":=", "[", "]", "string", "{", "cmds", ".", "start", "(", "name", ")", ",", "}", "\n", "return", "cmdList", ",", "nil", "\n", "}" ]

[ "StartCommands", "implements", "Service", "." ]

[ "func", "(", "s", "*", "Service", ")", "WriteService", "(", ")", "error", "{", "filename", ",", "err", ":=", "s", ".", "writeConf", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// If systemd is not the running init system,", "// then do not attempt to use it for linking unit files.", "if", "!", "IsRunning", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "conn", ",", "err", ":=", "s", ".", "newConn", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "runtime", ",", "force", ":=", "false", ",", "true", "\n", "if", "_", ",", "err", "=", "conn", ".", "LinkUnitFiles", "(", "[", "]", "string", "{", "filename", "}", ",", "runtime", ",", "force", ")", ";", "err", "!=", "nil", "{", "return", "s", ".", "errorf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "err", "=", "conn", ".", "Reload", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "s", ".", "errorf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "_", ",", "_", ",", "err", "=", "conn", ".", "EnableUnitFiles", "(", "[", "]", "string", "{", "filename", "}", ",", "runtime", ",", "force", ")", ";", "err", "!=", "nil", "{", "return", "s", ".", "errorf", "(", "err", ",", "\"", "\"", ")", "\n\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "WriteService", "implements", "UpgradableService", ".", "WriteService" ]

[ "func", "SysdReload", "(", ")", "error", "{", "err", ":=", "Cmdline", "{", "}", ".", "reload", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SysdReload", "reloads", "Service", "daemon", "." ]

[ "func", "ParseVersions", "(", "r", "io", ".", "Reader", ")", "(", "*", "Versions", ",", "error", ")", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "results", "Versions", "\n", "err", "=", "yaml", ".", "Unmarshal", "(", "data", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "results", ",", "nil", "\n", "}" ]

[ "ParseVersions", "constructs", "a", "versions", "object", "from", "a", "reader", ".." ]

[ "func", "(", "v", "*", "Versions", ")", "VersionsMatching", "(", "r", "io", ".", "Reader", ")", "(", "[", "]", "string", ",", "error", ")", "{", "hash", ":=", "sha256", ".", "New", "(", ")", "\n", "_", ",", "err", ":=", "io", ".", "Copy", "(", "hash", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "v", ".", "versionsMatchingHash", "(", "hex", ".", "EncodeToString", "(", "hash", ".", "Sum", "(", "nil", ")", ")", ")", ",", "nil", "\n", "}" ]

[ "VersionsMatching", "returns", "all", "version", "numbers", "for", "which", "the", "SHA256", "matches", "the", "content", "of", "the", "reader", "passed", "in", "." ]

[ "func", "(", "v", "*", "Versions", ")", "versionsMatchingHash", "(", "h", "string", ")", "[", "]", "string", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "h", ")", "\n", "var", "results", "[", "]", "string", "\n", "for", "i", ":=", "range", "v", ".", "Versions", "{", "if", "v", ".", "Versions", "[", "i", "]", ".", "SHA256", "==", "h", "{", "results", "=", "append", "(", "results", ",", "v", ".", "Versions", "[", "i", "]", ".", "Version", ")", "\n", "}", "\n", "}", "\n", "return", "results", "\n", "}" ]

[ "versionsMatchingHash", "returns", "all", "version", "numbers", "for", "which", "the", "SHA256", "matches", "the", "hash", "passed", "in", "." ]

[ "func", "(", "r", "*", "CharmStoreResolver", ")", "Resolve", "(", "client", "*", "httpbakery", ".", "Client", ",", "charmURL", "string", ")", "(", "string", ",", "error", ")", "{", "repo", ":=", "charmrepo", ".", "NewCharmStore", "(", "charmrepo", ".", "NewCharmStoreParams", "{", "BakeryClient", ":", "client", ",", "URL", ":", "r", ".", "csURL", ",", "}", ")", "\n\n", "curl", ",", "err", ":=", "charm", ".", "ParseURL", "(", "charmURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "// ignore local charm urls", "if", "curl", ".", "Schema", "==", "\"", "\"", "{", "return", "charmURL", ",", "nil", "\n", "}", "\n", "resolvedURL", ",", "_", ",", "err", ":=", "repo", ".", "Resolve", "(", "curl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "resolvedURL", ".", "String", "(", ")", ",", "nil", "\n", "}" ]

[ "Resolve", "implements", "the", "CharmResolver", "interface", "." ]

[ "func", "Manifold", "(", "config", "ManifoldConfig", ")", "dependency", ".", "Manifold", "{", "return", "dependency", ".", "Manifold", "{", "Inputs", ":", "[", "]", "string", "{", "config", ".", "APICallerName", ",", "}", ",", "Output", ":", "func", "(", "in", "worker", ".", "Worker", ",", "out", "interface", "{", "}", ")", "error", "{", "inWorker", ",", "_", ":=", "in", ".", "(", "*", "FanConfigurer", ")", "\n", "if", "inWorker", "==", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "inWorker", ",", "in", ")", "\n", "}", "\n", "switch", "outPointer", ":=", "out", ".", "(", "type", ")", "{", "case", "*", "bool", ":", "*", "outPointer", "=", "true", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "out", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ",", "Start", ":", "func", "(", "context", "dependency", ".", "Context", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "var", "apiCaller", "base", ".", "APICaller", "\n", "if", "err", ":=", "context", ".", "Get", "(", "config", ".", "APICallerName", ",", "&", "apiCaller", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "facade", ":=", "apifanconfigurer", ".", "NewFacade", "(", "apiCaller", ")", "\n\n", "fanconfigurer", ",", "err", ":=", "NewFanConfigurer", "(", "FanConfigurerConfig", "{", "Facade", ":", "facade", ",", "}", ",", "config", ".", "Clock", ")", "\n", "return", "fanconfigurer", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", ",", "}", "\n", "}" ]

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

[ "func", "(", "f", "*", "StatusHistoryFilter", ")", "Validate", "(", ")", "error", "{", "s", ":=", "f", ".", "Size", ">", "0", "\n", "t", ":=", "f", ".", "FromDate", "!=", "nil", "\n", "d", ":=", "f", ".", "Delta", "!=", "nil", "\n\n", "switch", "{", "case", "!", "(", "s", "||", "t", "||", "d", ")", ":", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "case", "s", "&&", "t", ":", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "case", "s", "&&", "d", ":", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "case", "t", "&&", "d", ":", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "that", "the", "minimum", "requirements", "of", "a", "StatusHistoryFilter", "are", "met", "." ]

[ "func", "(", "k", "HistoryKind", ")", "Valid", "(", ")", "bool", "{", "switch", "k", "{", "case", "KindUnit", ",", "KindUnitAgent", ",", "KindWorkload", ",", "KindMachineInstance", ",", "KindMachine", ",", "KindContainerInstance", ",", "KindContainer", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Valid", "will", "return", "true", "if", "the", "current", "kind", "is", "a", "valid", "one", "." ]

[ "func", "AllHistoryKind", "(", ")", "map", "[", "HistoryKind", "]", "string", "{", "return", "map", "[", "HistoryKind", "]", "string", "{", "KindUnit", ":", "\"", "\"", ",", "KindUnitAgent", ":", "\"", "\"", ",", "KindWorkload", ":", "\"", "\"", ",", "KindMachineInstance", ":", "\"", "\"", ",", "KindMachine", ":", "\"", "\"", ",", "KindContainerInstance", ":", "\"", "\"", ",", "KindContainer", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "AllHistoryKind", "will", "return", "all", "valid", "HistoryKinds", "." ]

[ "func", "IgnoreErrRemoved", "(", "err", "error", ")", "error", "{", "cause", ":=", "errors", ".", "Cause", "(", "err", ")", "\n", "if", "cause", "==", "ErrRemoved", "{", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "IgnoreErrRemoved", "returns", "nil", "if", "passed", "an", "error", "caused", "by", "ErrRemoved", "and", "otherwise", "returns", "the", "original", "error", "." ]

[ "func", "(", "c", "*", "debugLogCommand", ")", "Run", "(", "ctx", "*", "cmd", ".", "Context", ")", "(", "err", "error", ")", "{", "if", "c", ".", "tail", "{", "c", ".", "params", ".", "NoTail", "=", "false", "\n", "}", "else", "if", "c", ".", "notail", "{", "c", ".", "params", ".", "NoTail", "=", "true", "\n", "}", "else", "{", "// Set the default tail option to true if the caller is", "// using a terminal.", "c", ".", "params", ".", "NoTail", "=", "!", "isTerminal", "(", "ctx", ".", "Stdout", ")", "\n", "}", "\n\n", "client", ",", "err", ":=", "getDebugLogAPI", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "messages", ",", "err", ":=", "client", ".", "WatchDebugLog", "(", "c", ".", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "writer", ":=", "ansiterm", ".", "NewWriter", "(", "ctx", ".", "Stdout", ")", "\n", "if", "c", ".", "color", "{", "writer", ".", "SetColorCapable", "(", "true", ")", "\n", "}", "\n", "for", "{", "msg", ",", "ok", ":=", "<-", "messages", "\n", "if", "!", "ok", "{", "break", "\n", "}", "\n", "c", ".", "writeLogRecord", "(", "writer", ",", "msg", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Run", "retrieves", "the", "debug", "log", "via", "the", "API", "." ]

[ "func", "FormatCharmResource", "(", "res", "charmresource", ".", "Resource", ")", "FormattedCharmResource", "{", "return", "FormattedCharmResource", "{", "Name", ":", "res", ".", "Name", ",", "Type", ":", "res", ".", "Type", ".", "String", "(", ")", ",", "Path", ":", "res", ".", "Path", ",", "Description", ":", "res", ".", "Description", ",", "Revision", ":", "res", ".", "Revision", ",", "Origin", ":", "res", ".", "Origin", ".", "String", "(", ")", ",", "Fingerprint", ":", "res", ".", "Fingerprint", ".", "String", "(", ")", ",", "// ...the hex string.", "Size", ":", "res", ".", "Size", ",", "}", "\n", "}" ]

[ "FormatCharmResource", "converts", "the", "resource", "info", "into", "a", "FormattedCharmResource", "." ]

[ "func", "FormatAppResource", "(", "res", "resource", ".", "Resource", ")", "FormattedAppResource", "{", "used", ":=", "!", "res", ".", "IsPlaceholder", "(", ")", "\n", "result", ":=", "FormattedAppResource", "{", "ID", ":", "res", ".", "ID", ",", "ApplicationID", ":", "res", ".", "ApplicationID", ",", "Name", ":", "res", ".", "Name", ",", "Type", ":", "res", ".", "Type", ".", "String", "(", ")", ",", "Path", ":", "res", ".", "Path", ",", "Description", ":", "res", ".", "Description", ",", "Origin", ":", "res", ".", "Origin", ".", "String", "(", ")", ",", "Fingerprint", ":", "res", ".", "Fingerprint", ".", "String", "(", ")", ",", "Size", ":", "res", ".", "Size", ",", "Used", ":", "used", ",", "Timestamp", ":", "res", ".", "Timestamp", ",", "Username", ":", "res", ".", "Username", ",", "CombinedRevision", ":", "combinedRevision", "(", "res", ")", ",", "CombinedOrigin", ":", "combinedOrigin", "(", "used", ",", "res", ")", ",", "UsedYesNo", ":", "usedYesNo", "(", "used", ")", ",", "}", "\n", "// Have to check since revision 0 is still a valid revision.", "if", "res", ".", "Revision", ">=", "0", "{", "result", ".", "Revision", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "res", ".", "Revision", ")", "\n", "}", "else", "{", "result", ".", "Revision", "=", "\"", "\"", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "FormatAppResource", "converts", "the", "resource", "info", "into", "a", "FormattedAppResource", "." ]

[ "func", "FormatApplicationDetails", "(", "sr", "resource", ".", "ApplicationResources", ")", "(", "FormattedApplicationDetails", ",", "error", ")", "{", "var", "formatted", "FormattedApplicationDetails", "\n", "details", ",", "err", ":=", "detailedResources", "(", "\"", "\"", ",", "sr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "formatted", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "updates", ",", "err", ":=", "sr", ".", "Updates", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "formatted", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "formatted", "=", "FormattedApplicationDetails", "{", "Resources", ":", "details", ",", "Updates", ":", "make", "(", "[", "]", "FormattedCharmResource", ",", "len", "(", "updates", ")", ")", ",", "}", "\n", "for", "i", ",", "u", ":=", "range", "updates", "{", "formatted", ".", "Updates", "[", "i", "]", "=", "FormatCharmResource", "(", "u", ")", "\n", "}", "\n", "return", "formatted", ",", "nil", "\n", "}" ]

[ "FormatApplicationDetails", "converts", "a", "ApplicationResources", "value", "into", "a", "formatted", "value", "for", "display", "on", "the", "command", "line", "." ]

[ "func", "FormatDetailResource", "(", "tag", "names", ".", "UnitTag", ",", "svc", ",", "unit", "resource", ".", "Resource", ",", "progress", "int64", ")", "(", "FormattedDetailResource", ",", "error", ")", "{", "// note that the unit resource can be a zero value here, to indicate that", "// the unit has not downloaded that resource yet.", "unitNum", ",", "err", ":=", "unitNum", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "FormattedDetailResource", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "progressStr", ":=", "\"", "\"", "\n", "fUnit", ":=", "FormatAppResource", "(", "unit", ")", "\n", "expected", ":=", "FormatAppResource", "(", "svc", ")", "\n", "revProgress", ":=", "expected", ".", "CombinedRevision", "\n", "if", "progress", ">=", "0", "{", "progressStr", "=", "\"", "\"", "\n", "if", "expected", ".", "Size", ">", "0", "{", "progressStr", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "float64", "(", "progress", ")", "*", "100.0", "/", "float64", "(", "expected", ".", "Size", ")", ")", "\n", "}", "\n", "if", "fUnit", ".", "CombinedRevision", "!=", "expected", ".", "CombinedRevision", "{", "revProgress", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "expected", ".", "CombinedRevision", ",", "progressStr", ")", "\n", "}", "\n", "}", "\n", "return", "FormattedDetailResource", "{", "UnitID", ":", "tag", ".", "Id", "(", ")", ",", "UnitNumber", ":", "unitNum", ",", "Unit", ":", "fUnit", ",", "Expected", ":", "expected", ",", "Progress", ":", "progress", ",", "RevProgress", ":", "revProgress", ",", "}", ",", "nil", "\n", "}" ]

[ "FormatDetailResource", "converts", "the", "arguments", "into", "a", "FormattedApplicationResource", "." ]

[ "func", "detailedResources", "(", "unit", "string", ",", "sr", "resource", ".", "ApplicationResources", ")", "(", "[", "]", "FormattedDetailResource", ",", "error", ")", "{", "var", "formatted", "[", "]", "FormattedDetailResource", "\n", "for", "_", ",", "ur", ":=", "range", "sr", ".", "UnitResources", "{", "if", "unit", "==", "\"", "\"", "||", "unit", "==", "ur", ".", "Tag", ".", "Id", "(", ")", "{", "units", ":=", "resourceMap", "(", "ur", ".", "Resources", ")", "\n", "for", "_", ",", "svc", ":=", "range", "sr", ".", "Resources", "{", "progress", ",", "ok", ":=", "ur", ".", "DownloadProgress", "[", "svc", ".", "Name", "]", "\n", "if", "!", "ok", "{", "progress", "=", "-", "1", "\n", "}", "\n", "f", ",", "err", ":=", "FormatDetailResource", "(", "ur", ".", "Tag", ",", "svc", ",", "units", "[", "svc", ".", "Name", "]", ",", "progress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "formatted", "=", "append", "(", "formatted", ",", "f", ")", "\n", "}", "\n", "if", "unit", "!=", "\"", "\"", "{", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "formatted", ",", "nil", "\n", "}" ]

[ "detailedResources", "shows", "the", "version", "of", "each", "resource", "on", "each", "unit", "with", "the", "corresponding", "version", "of", "the", "resource", "that", "exists", "in", "the", "controller", ".", "if", "unit", "is", "non", "-", "empty", "only", "units", "matching", "that", "unitID", "will", "be", "returned", "." ]

[ "func", "(", "env", "*", "environ", ")", "ConstraintsValidator", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "constraints", ".", "Validator", ",", "error", ")", "{", "validator", ":=", "constraints", ".", "NewValidator", "(", ")", "\n", "validator", ".", "RegisterUnsupported", "(", "unsupportedConstraints", ")", "\n", "return", "validator", ",", "nil", "\n", "}" ]

[ "ConstraintsValidator", "returns", "a", "Validator", "instance", "which", "is", "used", "to", "validate", "and", "merge", "constraints", "." ]

[ "func", "NewDeadEnsurer", "(", "st", "state", ".", "EntityFinder", ",", "getCanModify", "GetAuthFunc", ")", "*", "DeadEnsurer", "{", "return", "&", "DeadEnsurer", "{", "st", ":", "st", ",", "getCanModify", ":", "getCanModify", ",", "}", "\n", "}" ]

[ "NewDeadEnsurer", "returns", "a", "new", "DeadEnsurer", ".", "The", "GetAuthFunc", "will", "be", "used", "on", "each", "invocation", "of", "EnsureDead", "to", "determine", "current", "permissions", "." ]

[ "func", "(", "config", "Config", ")", "Validate", "(", ")", "error", "{", "if", "config", ".", "Identity", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Start", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Clock", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "RetryDelay", "<=", "0", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "returns", "an", "error", "if", "Config", "cannot", "be", "expected", "to", "drive", "a", "Worker", "." ]

[ "func", "(", "w", "*", "Worker", ")", "loop", "(", ")", "error", "{", "var", "delay", "time", ".", "Duration", "\n", "for", "{", "select", "{", "case", "<-", "w", ".", "catacomb", ".", "Dying", "(", ")", ":", "return", "w", ".", "catacomb", ".", "ErrDying", "(", ")", "\n", "case", "<-", "w", ".", "config", ".", "Clock", ".", "After", "(", "delay", ")", ":", "maybePinger", ":=", "w", ".", "maybeStartPinger", "(", ")", "\n", "w", ".", "reportRunning", "(", ")", "\n", "w", ".", "waitPinger", "(", "maybePinger", ")", "\n", "}", "\n", "delay", "=", "w", ".", "config", ".", "RetryDelay", "\n", "}", "\n", "}" ]

[ "loop", "runs", "Pingers", "until", "w", "is", "stopped", "." ]

[ "func", "(", "w", "*", "Worker", ")", "maybeStartPinger", "(", ")", "Pinger", "{", "w", ".", "logger", ".", "Tracef", "(", "\"", "\"", ")", "\n", "pinger", ",", "err", ":=", "w", ".", "config", ".", "Start", "(", ")", "\n", "if", "err", "!=", "nil", "{", "w", ".", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "w", ".", "logger", ".", "Tracef", "(", "\"", "\"", ")", "\n", "return", "pinger", "\n", "}" ]

[ "maybeStartPinger", "starts", "and", "returns", "a", "new", "Pinger", ";", "or", "if", "it", "encounters", "an", "error", "logs", "it", "and", "returns", "nil", "." ]

[ "func", "(", "w", "*", "Worker", ")", "waitPinger", "(", "pinger", "Pinger", ")", "{", "if", "pinger", "==", "nil", "{", "return", "\n", "}", "\n\n", "// Set up a channel that will last as long as this method call.", "done", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "defer", "close", "(", "done", ")", "\n\n", "// Start a goroutine to stop the Pinger if the worker is killed.", "// If the enclosing method completes, we know that the Pinger", "// has already stopped, and we can return immediately.", "//", "// Note that we ignore errors out of Stop(), depending on the", "// Pinger to manage errors properly and report them via Wait()", "// below.", "go", "func", "(", ")", "{", "select", "{", "case", "<-", "done", ":", "case", "<-", "w", ".", "catacomb", ".", "Dying", "(", ")", ":", "w", ".", "logger", ".", "Tracef", "(", "\"", "\"", ")", "\n", "pinger", ".", "Stop", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Now, just wait for the Pinger to stop. It might be caused by", "// the Worker's death, or it might have failed on its own; in", "// any case, errors are worth recording, but we don't need to", "// respond in any way because that's loop()'s responsibility.", "w", ".", "logger", ".", "Tracef", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "pinger", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "w", ".", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "waitPinger", "waits", "for", "the", "death", "of", "either", "the", "pinger", "or", "the", "worker", ";", "stops", "the", "pinger", "if", "necessary", ";", "and", "returns", "once", "the", "pinger", "is", "finished", ".", "If", "pinger", "is", "nil", "it", "returns", "immediately", "." ]

[ "func", "(", "info", "*", "Info", ")", "Ports", "(", ")", "[", "]", "int", "{", "ports", ":=", "set", ".", "NewInts", "(", ")", "\n", "hostPorts", ",", "err", ":=", "network", ".", "ParseHostPorts", "(", "info", ".", "Addrs", "...", ")", "\n", "if", "err", "!=", "nil", "{", "// Addresses have already been validated.", "panic", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "hp", ":=", "range", "hostPorts", "{", "ports", ".", "Add", "(", "hp", ".", "Port", ")", "\n", "}", "\n", "return", "ports", ".", "Values", "(", ")", "\n", "}" ]

[ "Ports", "returns", "the", "unique", "ports", "for", "the", "api", "addresses", "." ]

[ "func", "(", "info", "*", "Info", ")", "Validate", "(", ")", "error", "{", "if", "len", "(", "info", ".", "Addrs", ")", "==", "0", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "network", ".", "ParseHostPorts", "(", "info", ".", "Addrs", "...", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "info", ".", "SkipLogin", "{", "if", "info", ".", "Tag", "!=", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "info", ".", "Password", "!=", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "info", ".", "Macaroons", ")", ">", "0", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "the", "API", "info", "." ]

[ "func", "DefaultDialOpts", "(", ")", "DialOpts", "{", "return", "DialOpts", "{", "DialAddressInterval", ":", "50", "*", "time", ".", "Millisecond", ",", "Timeout", ":", "10", "*", "time", ".", "Minute", ",", "RetryDelay", ":", "2", "*", "time", ".", "Second", ",", "}", "\n", "}" ]

[ "DefaultDialOpts", "returns", "a", "DialOpts", "representing", "the", "default", "parameters", "for", "contacting", "a", "controller", "." ]

[ "func", "getPackageManager", "(", ")", "(", "manager", ".", "PackageManager", ",", "error", ")", "{", "hostSeries", ",", "err", ":=", "series", ".", "HostSeries", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "manager", ".", "NewPackageManager", "(", "hostSeries", ")", "\n", "}" ]

[ "getPackageManager", "is", "a", "helper", "function", "which", "returns", "the", "package", "manager", "implementation", "for", "the", "current", "system", "." ]

[ "func", "ensurePool", "(", "poolInfo", "*", "libvirtPool", ",", "pathfinder", "func", "(", "string", ")", "(", "string", ",", "error", ")", ",", "runCmd", "runFunc", ",", "chownFunc", "func", "(", "string", ")", "error", ")", "error", "{", "poolDir", ",", "err", ":=", "guestPath", "(", "pathfinder", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "poolInfo", "==", "nil", "{", "poolInfo", "=", "&", "libvirtPool", "{", "}", "\n", "}", "\n\n", "if", "poolInfo", ".", "Name", "==", "\"", "\"", "{", "if", "err", "=", "definePool", "(", "poolDir", ",", "runCmd", ",", "chownFunc", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "`pool %q already created`", ",", "poolInfo", ".", "Name", ")", "\n", "}", "\n\n", "if", "poolInfo", ".", "State", "!=", "\"", "\"", "{", "if", "err", "=", "buildPool", "(", "runCmd", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "startPool", "(", "runCmd", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "`pool %q already active`", ",", "poolInfo", ".", "Name", ")", "\n", "}", "\n\n", "if", "poolInfo", ".", "Autostart", "!=", "\"", "\"", "{", "if", "err", "=", "autostartPool", "(", "runCmd", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "// We have to set ownership of the guest pool directory after running virsh", "// commands above, because it appears that the libvirt-bin version that", "// ships with trusty sets the ownership of the pool directory to the user", "// running the commands -- root in our case. Which causes container", "// initialization to fail as we couldn't write volumes to the pool. We", "// write them as libvirt-qemu:kvm so that libvirt -- which runs as that", "// user -- can read them to boot the domains.", "if", "err", "=", "chownFunc", "(", "poolDir", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ensurePool", "creates", "the", "libvirt", "storage", "pool", "and", "ensures", "its", "is", "active", ".", "runCmd", "and", "chownFunc", "are", "here", "for", "testing", ".", "runCmd", "so", "we", "can", "check", "the", "right", "shell", "out", "calls", "are", "made", "and", "chownFunc", "because", "we", "cannot", "chown", "unless", "we", "are", "root", "." ]

[ "func", "definePool", "(", "dir", "string", ",", "runCmd", "runFunc", ",", "_", "func", "(", "string", ")", "error", ")", "error", "{", "// Permissions gleaned from https://goo.gl/SZIw14", "// The command itself would change the permissions to match anyhow.", "err", ":=", "os", ".", "MkdirAll", "(", "dir", ",", "0755", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// The dashes are empty positional args for other types of pool storage:", "// e.g. file, lvm, scsi, disk, NFS. Newer versions support using only named", "// args (--type, --target) but this is backwards compatible for trusty.", "output", ",", "err", ":=", "runCmd", "(", "\"", "\"", ",", "virsh", ",", "\"", "\"", ",", "poolName", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "dir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "output", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "definePool", "creates", "the", "required", "directories", "and", "changes", "ownership", "of", "the", "guest", "directory", "so", "that", "libvirt", "-", "qemu", "can", "read", "write", "and", "execute", "its", "guest", "volumes", "." ]

[ "func", "buildPool", "(", "runCmd", "runFunc", ")", "error", "{", "// This can run without error if the pool isn't active.", "output", ",", "err", ":=", "runCmd", "(", "\"", "\"", ",", "virsh", ",", "\"", "\"", ",", "poolName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "output", ")", "\n", "return", "nil", "\n", "}" ]

[ "buildPool", "sets", "up", "libvirt", "internals", "for", "the", "guest", "pool", "." ]

[ "func", "NewPoolCreateCommand", "(", ")", "cmd", ".", "Command", "{", "cmd", ":=", "&", "poolCreateCommand", "{", "}", "\n", "cmd", ".", "newAPIFunc", "=", "func", "(", ")", "(", "PoolCreateAPI", ",", "error", ")", "{", "return", "cmd", ".", "NewStorageAPI", "(", ")", "\n", "}", "\n", "return", "modelcmd", ".", "Wrap", "(", "cmd", ")", "\n", "}" ]

[ "NewPoolCreateCommand", "returns", "a", "command", "that", "creates", "or", "defines", "a", "storage", "pool" ]

[ "func", "NewMockModelCache", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockModelCache", "{", "mock", ":=", "&", "MockModelCache", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockModelCacheMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "NewMockModelCacheMachine", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockModelCacheMachine", "{", "mock", ":=", "&", "MockModelCacheMachine", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockModelCacheMachineMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "NewMockModelCacheApplication", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockModelCacheApplication", "{", "mock", ":=", "&", "MockModelCacheApplication", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockModelCacheApplicationMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

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

[ "CharmURL", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockModelCacheApplicationMockRecorder", ")", "CharmURL", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockModelCacheApplication", ")", "(", "nil", ")", ".", "CharmURL", ")", ")", "\n", "}" ]

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

[ "func", "NewMockModelCacheUnit", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockModelCacheUnit", "{", "mock", ":=", "&", "MockModelCacheUnit", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockModelCacheUnitMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "NewMockModelCacheCharm", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockModelCacheCharm", "{", "mock", ":=", "&", "MockModelCacheCharm", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockModelCacheCharmMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "c", "*", "addUnitCommand", ")", "IncompatibleModel", "(", "err", "error", ")", "error", "{", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "msg", ":=", "`\nadd-unit is not allowed on Kubernetes models.\nInstead, use juju scale-application.\nSee juju help scale-application.\n`", "[", "1", ":", "]", "\n", "return", "errors", ".", "New", "(", "msg", ")", "\n", "}" ]

[ "IncompatibleModel", "returns", "an", "error", "if", "the", "command", "is", "being", "run", "against", "a", "model", "with", "which", "it", "is", "not", "compatible", "." ]

[ "func", "(", "c", "*", "addUnitCommand", ")", "Run", "(", "ctx", "*", "cmd", ".", "Context", ")", "error", "{", "apiclient", ",", "err", ":=", "c", ".", "getAPI", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "apiclient", ".", "Close", "(", ")", "\n\n", "if", "c", ".", "unknownModel", "{", "if", "err", ":=", "c", ".", "validateArgsByModelType", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "modelType", ",", "err", ":=", "c", ".", "ModelType", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "modelType", "==", "model", ".", "CAAS", "{", "_", ",", "err", "=", "apiclient", ".", "ScaleApplication", "(", "application", ".", "ScaleApplicationParams", "{", "ApplicationName", ":", "c", ".", "ApplicationName", ",", "ScaleChange", ":", "c", ".", "NumUnits", ",", "}", ")", "\n", "if", "params", ".", "IsCodeUnauthorized", "(", "err", ")", "{", "common", ".", "PermissionsMessage", "(", "ctx", ".", "Stderr", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "block", ".", "ProcessBlockedError", "(", "err", ",", "block", ".", "BlockChange", ")", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "AttachStorage", ")", ">", "0", "&&", "apiclient", ".", "BestAPIVersion", "(", ")", "<", "5", "{", "// AddUnitsPArams.AttachStorage is only supported from", "// Application API version 5 and onwards.", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "for", "i", ",", "p", ":=", "range", "c", ".", "Placement", "{", "if", "p", ".", "Scope", "==", "\"", "\"", "{", "p", ".", "Scope", "=", "apiclient", ".", "ModelUUID", "(", ")", "\n", "}", "\n", "c", ".", "Placement", "[", "i", "]", "=", "p", "\n", "}", "\n", "_", ",", "err", "=", "apiclient", ".", "AddUnits", "(", "application", ".", "AddUnitsParams", "{", "ApplicationName", ":", "c", ".", "ApplicationName", ",", "NumUnits", ":", "c", ".", "NumUnits", ",", "Placement", ":", "c", ".", "Placement", ",", "AttachStorage", ":", "c", ".", "AttachStorage", ",", "}", ")", "\n", "if", "params", ".", "IsCodeUnauthorized", "(", "err", ")", "{", "common", ".", "PermissionsMessage", "(", "ctx", ".", "Stderr", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "block", ".", "ProcessBlockedError", "(", "err", ",", "block", ".", "BlockChange", ")", "\n", "}" ]

[ "Run", "connects", "to", "the", "environment", "specified", "on", "the", "command", "line", "and", "calls", "AddUnits", "for", "the", "given", "application", "." ]

[ "func", "(", "status", "Status", ")", "KnownModificationStatus", "(", ")", "bool", "{", "switch", "status", "{", "case", "Idle", ",", "Applied", ",", "Error", ",", "Unknown", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "KnownModificationStatus", "returns", "true", "if", "the", "status", "has", "a", "known", "value", "for", "a", "modification", "of", "an", "instance", "." ]

[ "func", "(", "status", "Status", ")", "KnownAgentStatus", "(", ")", "bool", "{", "switch", "status", "{", "case", "Allocating", ",", "Error", ",", "Failed", ",", "Rebooting", ",", "Executing", ",", "Idle", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "KnownAgentStatus", "returns", "true", "if", "status", "has", "a", "known", "value", "for", "an", "agent", ".", "It", "includes", "every", "status", "that", "has", "ever", "been", "valid", "for", "a", "unit", "or", "machine", "agent", ".", "This", "is", "used", "by", "the", "apiserver", "client", "facade", "to", "filter", "out", "unknown", "values", "." ]

[ "func", "(", "status", "Status", ")", "KnownWorkloadStatus", "(", ")", "bool", "{", "if", "ValidWorkloadStatus", "(", "status", ")", "{", "return", "true", "\n", "}", "\n", "switch", "status", "{", "case", "Error", ":", "// include error so that we can filter on what the spec says is valid", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "KnownWorkloadStatus", "returns", "true", "if", "status", "has", "a", "known", "value", "for", "a", "workload", ".", "It", "includes", "every", "status", "that", "has", "ever", "been", "valid", "for", "a", "unit", "agent", ".", "This", "is", "used", "by", "the", "apiserver", "client", "facade", "to", "filter", "out", "unknown", "values", "." ]

[ "func", "Destroy", "(", "env", "environs", ".", "Environ", ",", "ctx", "context", ".", "ProviderCallContext", ")", "error", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "env", ".", "Config", "(", ")", ".", "Name", "(", ")", ")", "\n", "if", "err", ":=", "destroyInstances", "(", "env", ",", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "destroyStorage", "(", "env", ",", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Destroy", "is", "a", "common", "implementation", "of", "the", "Destroy", "method", "defined", "on", "environs", ".", "Environ", ";", "we", "strongly", "recommend", "that", "this", "implementation", "be", "used", "when", "writing", "a", "new", "provider", "." ]

[ "func", "(", "ps", "*", "PooledState", ")", "Release", "(", ")", "bool", "{", "if", "ps", ".", "isSystemState", "||", "ps", ".", "released", "{", "return", "false", "\n", "}", "\n\n", "removed", ",", "err", ":=", "ps", ".", "pool", ".", "release", "(", "ps", ".", "modelUUID", ",", "ps", ".", "itemKey", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "ps", ".", "released", "=", "true", "\n", "return", "removed", "\n", "}" ]

[ "Release", "indicates", "that", "the", "pooled", "state", "is", "no", "longer", "required", "and", "can", "be", "removed", "from", "the", "pool", "if", "there", "are", "no", "other", "references", "to", "it", ".", "The", "return", "indicates", "whether", "the", "released", "state", "was", "actually", "removed", "from", "the", "pool", "-", "items", "marked", "for", "removal", "are", "only", "removed", "when", "released", "by", "all", "other", "reference", "holders", "." ]

[ "func", "OpenStatePool", "(", "args", "OpenParams", ")", "(", "*", "StatePool", ",", "error", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "args", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "pool", ":=", "&", "StatePool", "{", "pool", ":", "make", "(", "map", "[", "string", "]", "*", "PoolItem", ")", ",", "hub", ":", "pubsub", ".", "NewSimpleHub", "(", "nil", ")", ",", "}", "\n\n", "session", ":=", "args", ".", "MongoSession", ".", "Copy", "(", ")", "\n", "st", ",", "err", ":=", "open", "(", "args", ".", "ControllerModelTag", ",", "session", ",", "args", ".", "InitDatabaseFunc", ",", "nil", ",", "args", ".", "NewPolicy", ",", "args", ".", "Clock", ",", "args", ".", "RunTransactionObserver", ",", ")", "\n", "if", "err", "!=", "nil", "{", "session", ".", "Close", "(", ")", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "if", "closeErr", ":=", "st", ".", "Close", "(", ")", ";", "closeErr", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "args", ".", "ControllerModelTag", ",", "closeErr", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "// If the InitDatabaseFunc is set, then we are initializing the", "// database, and the model won't be there. So we only look for the model", "// if we aren't initializing.", "if", "args", ".", "InitDatabaseFunc", "==", "nil", "{", "if", "_", ",", "err", "=", "st", ".", "Model", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "mongo", ".", "MaybeUnauthorizedf", "(", "err", ",", "\"", "\"", ",", "args", ".", "ControllerModelTag", ".", "Id", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n", "if", "err", "=", "st", ".", "start", "(", "args", ".", "ControllerTag", ",", "pool", ".", "hub", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "pool", ".", "systemState", "=", "st", "\n", "// When creating the txn watchers and the worker to keep it running", "// we really want to use wall clocks. Otherwise the events never get", "// noticed. The clocks in the runner and the txn watcher are used to", "// control polling, and never return the actual times.", "pool", ".", "watcherRunner", "=", "worker", ".", "NewRunner", "(", "worker", ".", "RunnerParams", "{", "// TODO add a Logger parameter to RunnerParams:", "// Logger: loggo.GetLogger(logger.Name() + \".txnwatcher\"),", "IsFatal", ":", "func", "(", "err", "error", ")", "bool", "{", "return", "errors", ".", "Cause", "(", "err", ")", "==", "errPoolClosed", "}", ",", "RestartDelay", ":", "time", ".", "Second", ",", "Clock", ":", "args", ".", "Clock", ",", "}", ")", "\n", "pool", ".", "watcherRunner", ".", "StartWorker", "(", "txnLogWorker", ",", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "return", "watcher", ".", "NewTxnWatcher", "(", "watcher", ".", "TxnWatcherConfig", "{", "ChangeLog", ":", "st", ".", "getTxnLogCollection", "(", ")", ",", "Hub", ":", "pool", ".", "hub", ",", "Clock", ":", "args", ".", "Clock", ",", "Logger", ":", "loggo", ".", "GetLogger", "(", "\"", "\"", ")", ",", "}", ")", "\n", "}", ")", "\n", "return", "pool", ",", "nil", "\n", "}" ]

[ "OpenStatePool", "returns", "a", "new", "StatePool", "instance", "." ]

[ "func", "(", "p", "*", "StatePool", ")", "Get", "(", "modelUUID", "string", ")", "(", "*", "PooledState", ",", "error", ")", "{", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "p", ".", "pool", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "modelUUID", "==", "p", ".", "systemState", ".", "ModelUUID", "(", ")", "{", "return", "newPooledState", "(", "p", ".", "systemState", ",", "p", ",", "modelUUID", ",", "true", ")", ",", "nil", "\n", "}", "\n\n", "item", ",", "ok", ":=", "p", ".", "pool", "[", "modelUUID", "]", "\n", "if", "ok", "&&", "item", ".", "remove", "{", "// Disallow further usage of a pool item marked for removal.", "return", "nil", ",", "errors", ".", "NewNotFound", "(", "nil", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "modelUUID", ")", ")", "\n", "}", "\n\n", "p", ".", "sourceKey", "++", "\n", "key", ":=", "p", ".", "sourceKey", "\n\n", "source", ":=", "string", "(", "debug", ".", "Stack", "(", ")", ")", "\n\n", "// Already have a state in the pool for this model; use it.", "if", "ok", "{", "item", ".", "referenceSources", "[", "key", "]", "=", "source", "\n", "ps", ":=", "newPooledState", "(", "item", ".", "state", ",", "p", ",", "modelUUID", ",", "false", ")", "\n", "ps", ".", "itemKey", "=", "key", "\n", "return", "ps", ",", "nil", "\n", "}", "\n\n", "// Don't create any new pool objects if the state pool is in the", "// process of closing down.", "if", "p", ".", "closing", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// We need a new state and pool item.", "st", ",", "err", ":=", "p", ".", "openState", "(", "modelUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "p", ".", "pool", "[", "modelUUID", "]", "=", "&", "PoolItem", "{", "modelUUID", ":", "modelUUID", ",", "state", ":", "st", ",", "referenceSources", ":", "map", "[", "uint64", "]", "string", "{", "key", ":", "source", ",", "}", ",", "}", "\n", "ps", ":=", "newPooledState", "(", "st", ",", "p", ",", "modelUUID", ",", "false", ")", "\n", "ps", ".", "itemKey", "=", "key", "\n", "return", "ps", ",", "nil", "\n", "}" ]

[ "Get", "returns", "a", "PooledState", "for", "a", "given", "model", "creating", "a", "new", "State", "instance", "if", "required", ".", "If", "the", "State", "has", "been", "marked", "for", "removal", "an", "error", "is", "returned", "." ]

[ "func", "(", "p", "*", "StatePool", ")", "GetModel", "(", "modelUUID", "string", ")", "(", "*", "Model", ",", "PoolHelper", ",", "error", ")", "{", "ps", ",", "err", ":=", "p", ".", "Get", "(", "modelUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "model", ",", "err", ":=", "ps", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "ps", ".", "Release", "(", ")", "\n", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "model", ",", "ps", ",", "nil", "\n", "}" ]

[ "GetModel", "is", "a", "convenience", "method", "for", "getting", "a", "Model", "for", "a", "State", "." ]

[ "func", "(", "p", "*", "StatePool", ")", "release", "(", "modelUUID", "string", ",", "key", "uint64", ")", "(", "bool", ",", "error", ")", "{", "if", "modelUUID", "==", "p", ".", "systemState", ".", "ModelUUID", "(", ")", "{", "// We do not monitor usage of the controller's state.", "return", "false", ",", "nil", "\n", "}", "\n\n", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "p", ".", "pool", "==", "nil", "{", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "item", ",", "ok", ":=", "p", ".", "pool", "[", "modelUUID", "]", "\n", "if", "!", "ok", "{", "return", "false", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "modelUUID", ")", "\n", "}", "\n", "if", "item", ".", "refCount", "(", ")", "==", "0", "{", "return", "false", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "modelUUID", ")", "\n", "}", "\n", "delete", "(", "item", ".", "referenceSources", ",", "key", ")", "\n", "return", "p", ".", "maybeRemoveItem", "(", "item", ")", "\n", "}" ]

[ "release", "indicates", "that", "the", "client", "has", "finished", "using", "the", "State", ".", "If", "the", "state", "has", "been", "marked", "for", "removal", "it", "will", "be", "closed", "and", "removed", "when", "the", "final", "Release", "is", "done", ";", "if", "there", "are", "no", "references", "it", "will", "be", "closed", "and", "removed", "immediately", ".", "The", "boolean", "result", "reports", "whether", "or", "not", "the", "state", "was", "closed", "and", "removed", "." ]

[ "func", "(", "p", "*", "StatePool", ")", "SystemState", "(", ")", "*", "State", "{", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "// State pool is closed, no more access to the system state.", "if", "p", ".", "pool", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "p", ".", "systemState", "\n", "}" ]

[ "SystemState", "returns", "the", "State", "passed", "in", "to", "NewStatePool", "." ]

[ "func", "(", "p", "*", "StatePool", ")", "Close", "(", ")", "error", "{", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "// A nil pool map indicates that the pool has already been closed.", "if", "p", ".", "pool", "==", "nil", "{", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\\n", "\"", ",", "debug", ".", "Stack", "(", ")", ")", "\n\n", "// Before we go through and close the state pool objects, we need to", "// stop all the workers running in the state objects. If anyone had asked", "// for a mutliwatcher, an all watcher worker is stated in the state object's", "// workers. These need to be stopped before we start closing connections", "// as those workers use the pool.", "p", ".", "closing", "=", "true", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "for", "uuid", ",", "item", ":=", "range", "p", ".", "pool", "{", "if", "err", ":=", "item", ".", "state", ".", "stopWorkers", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "uuid", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "p", ".", "systemState", ".", "stopWorkers", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Reacquire the lock to modify the pool.", "// Hopefully by now any workers running that may have released objects", "// to the pool should be fine.", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "pool", ":=", "p", ".", "pool", "\n", "p", ".", "pool", "=", "nil", "\n", "var", "lastErr", "error", "\n", "// We release the lock as we are closing the state objects to allow", "// other goroutines that may be attempting to Get a model from the pool", "// to continue. The Get method will fail with a closed pool.", "// We do this just in case the workers didn't stop above when we were trying.", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "item", ":=", "range", "pool", "{", "if", "item", ".", "refCount", "(", ")", "!=", "0", "||", "item", ".", "remove", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "item", ".", "state", ".", "ModelUUID", "(", ")", ",", "item", ".", "refCount", "(", ")", ",", "item", ".", "remove", ",", ")", "\n", "}", "\n", "err", ":=", "item", ".", "state", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "lastErr", "=", "err", "\n", "}", "\n", "}", "\n", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "p", ".", "watcherRunner", "!=", "nil", "{", "worker", ".", "Stop", "(", "p", ".", "watcherRunner", ")", "\n", "}", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "// As with above and the other watchers. Unlock while releas", "if", "err", ":=", "p", ".", "systemState", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "lastErr", "=", "err", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "lastErr", ",", "\"", "\"", ")", "\n", "}" ]

[ "Close", "closes", "all", "State", "instances", "in", "the", "pool", "." ]

[ "func", "(", "p", "*", "StatePool", ")", "IntrospectionReport", "(", ")", "string", "{", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "removeCount", ":=", "0", "\n", "buff", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n\n", "for", "uuid", ",", "item", ":=", "range", "p", ".", "pool", "{", "if", "item", ".", "remove", "{", "removeCount", "++", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "buff", ",", "\"", "\\n", "\\n", "\"", ",", "uuid", ")", "\n", "fmt", ".", "Fprintf", "(", "buff", ",", "\"", "\\n", "\"", ",", "item", ".", "remove", ")", "\n", "fmt", ".", "Fprintf", "(", "buff", ",", "\"", "\\n", "\"", ",", "item", ".", "refCount", "(", ")", ")", "\n", "index", ":=", "0", "\n", "for", "_", ",", "ref", ":=", "range", "item", ".", "referenceSources", "{", "index", "++", "\n", "fmt", ".", "Fprintf", "(", "buff", ",", "\"", "\\n", "\\n", "\"", ",", "index", ",", "ref", ")", "\n", "}", "\n", "item", ".", "state", ".", "workers", ".", "Runner", ".", "Report", "(", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", ",", "len", "(", "p", ".", "pool", ")", ",", "removeCount", ",", "buff", ")", "\n", "}" ]

[ "IntrospectionReport", "produces", "the", "output", "for", "the", "introspection", "worker", "in", "order", "to", "look", "inside", "the", "state", "pool", "." ]

[ "func", "(", "cache", "*", "charmstoreEntityCache", ")", "GetResource", "(", "name", "string", ")", "(", "resource", ".", "Resource", ",", "error", ")", "{", "return", "cache", ".", "st", ".", "GetResource", "(", "cache", ".", "applicationID", ",", "name", ")", "\n", "}" ]

[ "GetResource", "implements", "charmstore", ".", "EntityCache", "." ]