Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "(", "a", "*", "Application", ")", "SetAgentPresence", "(", ")", "(", "*", "presence", ".", "Pinger", ",", "error", ")", "{", "presenceCollection", ":=", "a", ".", "st", ".", "getPresenceCollection", "(", ")", "\n", "recorder", ":=", "a", ".", "st", ".", "getPingBatcher", "(", ")", "\n", "m", ",", "err", ":=", "a", ".", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "p", ":=", "presence", ".", "NewPinger", "(", "presenceCollection", ",", "m", ".", "ModelTag", "(", ")", ",", "a", ".", "globalKey", "(", ")", ",", "func", "(", ")", "presence", ".", "PingRecorder", "{", "return", "a", ".", "st", ".", "getPingBatcher", "(", ")", "}", ")", "\n", "err", "=", "p", ".", "Start", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Make sure this Agent status is written to the database before returning.", "recorder", ".", "Sync", "(", ")", "\n", "return", "p", ",", "nil", "\n", "}" ]

[ "SetAgentPresence", "signals", "that", "the", "agent", "for", "application", "a", "is", "alive", ".", "It", "returns", "the", "started", "pinger", "." ]

[ "func", "(", "a", "*", "Application", ")", "UpdateCloudService", "(", "providerId", "string", ",", "addresses", "[", "]", "network", ".", "Address", ")", "error", "{", "_", ",", "err", ":=", "a", ".", "st", ".", "SaveCloudService", "(", "SaveCloudServiceArgs", "{", "Id", ":", "a", ".", "Name", "(", ")", ",", "ProviderId", ":", "providerId", ",", "Addresses", ":", "addresses", ",", "}", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "UpdateCloudService", "updates", "the", "cloud", "service", "details", "for", "the", "application", "." ]

[ "func", "(", "a", "*", "Application", ")", "ServiceInfo", "(", ")", "(", "CloudService", ",", "error", ")", "{", "svc", ",", "err", ":=", "a", ".", "st", ".", "CloudService", "(", "a", ".", "Name", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "CloudService", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "*", "svc", ",", "nil", "\n", "}" ]

[ "ServiceInfo", "returns", "information", "about", "this", "application", "s", "cloud", "service", ".", "This", "is", "only", "used", "for", "CAAS", "models", "." ]

[ "func", "(", "a", "*", "Application", ")", "UnitNames", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "u", ",", "err", ":=", "appUnitNames", "(", "a", ".", "st", ",", "a", ".", "Name", "(", ")", ")", "\n", "return", "u", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "UnitNames", "returns", "the", "of", "this", "application", "s", "units", "." ]

[ "func", "(", "g", "*", "modelShim", ")", "Branch", "(", "name", "string", ")", "(", "Generation", ",", "error", ")", "{", "m", ",", "err", ":=", "g", ".", "Model", ".", "Branch", "(", "name", ")", "\n", "return", "m", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "Branch", "wraps", "the", "state", "model", "branch", "method", "returning", "the", "locally", "defined", "Generation", "interface", "." ]

[ "func", "(", "g", "*", "modelShim", ")", "Branches", "(", ")", "(", "[", "]", "Generation", ",", "error", ")", "{", "branches", ",", "err", ":=", "g", ".", "Model", ".", "Branches", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "res", ":=", "make", "(", "[", "]", "Generation", ",", "len", "(", "branches", ")", ")", "\n", "for", "i", ",", "b", ":=", "range", "branches", "{", "res", "[", "i", "]", "=", "b", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "Branches", "wraps", "the", "state", "model", "branches", "method", "returning", "a", "collection", "of", "the", "Generation", "interface", "." ]

[ "func", "(", "a", "*", "applicationShim", ")", "DefaultCharmConfig", "(", ")", "(", "charm", ".", "Settings", ",", "error", ")", "{", "ch", ",", "_", ",", "err", ":=", "a", ".", "Charm", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "ch", ".", "Config", "(", ")", ".", "DefaultSettings", "(", ")", ",", "nil", "\n", "}" ]

[ "DefaultCharmConfig", "returns", "the", "default", "configuration", "for", "this", "application", "s", "charm", "." ]

[ "func", "(", "env", "*", "joyentEnviron", ")", "FindInstanceSpec", "(", "ic", "*", "instances", ".", "InstanceConstraint", ",", "imageMetadata", "[", "]", "*", "imagemetadata", ".", "ImageMetadata", ",", ")", "(", "*", "instances", ".", "InstanceSpec", ",", "error", ")", "{", "// Require at least one VCPU so we get KVM rather than smart package.", "if", "ic", ".", "Constraints", ".", "CpuCores", "==", "nil", "{", "ic", ".", "Constraints", ".", "CpuCores", "=", "&", "defaultCpuCores", "\n", "}", "\n", "allInstanceTypes", ",", "err", ":=", "env", ".", "listInstanceTypes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "images", ":=", "instances", ".", "ImageMetadataToImages", "(", "imageMetadata", ")", "\n", "spec", ",", "err", ":=", "instances", ".", "FindInstanceSpec", "(", "images", ",", "ic", ",", "allInstanceTypes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "spec", ",", "nil", "\n", "}" ]

[ "FindInstanceSpec", "returns", "an", "InstanceSpec", "satisfying", "the", "supplied", "instanceConstraint", "." ]

[ "func", "(", "api", "*", "BaseAPI", ")", "checkPermission", "(", "tag", "names", ".", "Tag", ",", "perm", "permission", ".", "Access", ")", "error", "{", "allowed", ",", "err", ":=", "api", ".", "Authorizer", ".", "HasPermission", "(", "perm", ",", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "allowed", "{", "return", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "checkPermission", "ensures", "that", "the", "logged", "in", "user", "holds", "the", "given", "permission", "on", "an", "entity", "." ]

[ "func", "(", "api", "*", "BaseAPI", ")", "checkAdmin", "(", "backend", "Backend", ")", "error", "{", "allowed", ",", "err", ":=", "api", ".", "Authorizer", ".", "HasPermission", "(", "permission", ".", "AdminAccess", ",", "backend", ".", "ModelTag", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "allowed", "{", "allowed", ",", "err", "=", "api", ".", "Authorizer", ".", "HasPermission", "(", "permission", ".", "SuperuserAccess", ",", "backend", ".", "ControllerTag", "(", ")", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "allowed", "{", "return", "common", ".", "ErrPerm", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "checkAdmin", "ensures", "that", "the", "logged", "in", "user", "is", "a", "model", "or", "controller", "admin", "." ]

[ "func", "(", "api", "*", "BaseAPI", ")", "applicationOffersFromModel", "(", "modelUUID", "string", ",", "requiredAccess", "permission", ".", "Access", ",", "filters", "...", "jujucrossmodel", ".", "ApplicationOfferFilter", ",", ")", "(", "[", "]", "params", ".", "ApplicationOfferAdminDetails", ",", "error", ")", "{", "// Get the relevant backend for the specified model.", "backend", ",", "releaser", ",", "err", ":=", "api", ".", "StatePool", ".", "Get", "(", "modelUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "releaser", "(", ")", "\n\n", "// If requireAdmin is true, the user must be a controller superuser", "// or model admin to proceed.", "isAdmin", ":=", "false", "\n", "err", "=", "api", ".", "checkAdmin", "(", "backend", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "common", ".", "ErrPerm", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "isAdmin", "=", "err", "==", "nil", "\n", "if", "requiredAccess", "==", "permission", ".", "AdminAccess", "&&", "!", "isAdmin", "{", "return", "nil", ",", "common", ".", "ErrPerm", "\n", "}", "\n\n", "offers", ",", "err", ":=", "api", ".", "GetApplicationOffers", "(", "backend", ")", ".", "ListOffers", "(", "filters", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "apiUserTag", ":=", "api", ".", "Authorizer", ".", "GetAuthTag", "(", ")", ".", "(", "names", ".", "UserTag", ")", "\n", "apiUserDisplayName", ",", "err", ":=", "api", ".", "userDisplayName", "(", "backend", ",", "apiUserTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "var", "results", "[", "]", "params", ".", "ApplicationOfferAdminDetails", "\n", "for", "_", ",", "appOffer", ":=", "range", "offers", "{", "userAccess", ":=", "permission", ".", "AdminAccess", "\n", "// If the user is not a model admin, they need at least read", "// access on an offer to see it.", "if", "!", "isAdmin", "{", "if", "userAccess", ",", "err", "=", "api", ".", "checkOfferAccess", "(", "backend", ",", "appOffer", ".", "OfferUUID", ",", "requiredAccess", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "userAccess", "==", "permission", ".", "NoAccess", "{", "continue", "\n", "}", "\n", "isAdmin", "=", "userAccess", "==", "permission", ".", "AdminAccess", "\n", "}", "\n", "offerParams", ",", "app", ",", "err", ":=", "api", ".", "makeOfferParams", "(", "backend", ",", "&", "appOffer", ")", "\n", "// Just because we can't compose the result for one offer, log", "// that and move on to the next one.", "if", "err", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "offerParams", ".", "Users", "=", "[", "]", "params", ".", "OfferUserDetails", "{", "{", "UserName", ":", "apiUserTag", ".", "Id", "(", ")", ",", "DisplayName", ":", "apiUserDisplayName", ",", "Access", ":", "string", "(", "userAccess", ")", ",", "}", "}", "\n", "offer", ":=", "params", ".", "ApplicationOfferAdminDetails", "{", "ApplicationOfferDetails", ":", "*", "offerParams", ",", "}", "\n", "// Only admins can see some sensitive details of the offer.", "if", "isAdmin", "{", "if", "err", ":=", "api", ".", "getOfferAdminDetails", "(", "backend", ",", "app", ",", "&", "offer", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "results", "=", "append", "(", "results", ",", "offer", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "applicationOffersFromModel", "gets", "details", "about", "remote", "applications", "that", "match", "given", "filters", "." ]

[ "func", "(", "api", "*", "BaseAPI", ")", "checkOfferAccess", "(", "backend", "Backend", ",", "offerUUID", "string", ",", "perm", "permission", ".", "Access", ")", "(", "permission", ".", "Access", ",", "error", ")", "{", "apiUser", ":=", "api", ".", "Authorizer", ".", "GetAuthTag", "(", ")", ".", "(", "names", ".", "UserTag", ")", "\n", "access", ",", "err", ":=", "backend", ".", "GetOfferAccess", "(", "offerUUID", ",", "apiUser", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "permission", ".", "NoAccess", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "access", ".", "EqualOrGreaterOfferAccessThan", "(", "permission", ".", "ReadAccess", ")", "{", "return", "permission", ".", "NoAccess", ",", "nil", "\n", "}", "\n", "return", "access", ",", "nil", "\n", "}" ]

[ "checkOfferAccess", "returns", "the", "level", "of", "access", "the", "authenticated", "user", "has", "to", "the", "offer", "so", "long", "as", "it", "is", "greater", "than", "the", "requested", "perm", "." ]

[ "func", "(", "api", "*", "BaseAPI", ")", "getModelsFromOffers", "(", "offerURLs", "...", "string", ")", "(", "[", "]", "offerModel", ",", "error", ")", "{", "// Cache the models found so far so we don't look them up more than once.", "modelsCache", ":=", "make", "(", "map", "[", "string", "]", "Model", ")", "\n", "oneModel", ":=", "func", "(", "offerURL", "string", ")", "(", "Model", ",", "error", ")", "{", "url", ",", "err", ":=", "jujucrossmodel", ".", "ParseOfferURL", "(", "offerURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "modelPath", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "url", ".", "User", ",", "url", ".", "ModelName", ")", "\n", "if", "model", ",", "ok", ":=", "modelsCache", "[", "modelPath", "]", ";", "ok", "{", "return", "model", ",", "nil", "\n", "}", "\n\n", "model", ",", "absModelPath", ",", "ok", ",", "err", ":=", "api", ".", "modelForName", "(", "url", ".", "ModelName", ",", "url", ".", "User", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "absModelPath", ")", "\n", "}", "\n", "return", "model", ",", "nil", "\n", "}", "\n\n", "result", ":=", "make", "(", "[", "]", "offerModel", ",", "len", "(", "offerURLs", ")", ")", "\n", "for", "i", ",", "offerURL", ":=", "range", "offerURLs", "{", "var", "om", "offerModel", "\n", "om", ".", "model", ",", "om", ".", "err", "=", "oneModel", "(", "offerURL", ")", "\n", "result", "[", "i", "]", "=", "om", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "getModelsFromOffers", "returns", "a", "slice", "of", "models", "corresponding", "to", "the", "specified", "offer", "URLs", ".", "Each", "result", "item", "has", "either", "a", "model", "or", "an", "error", "." ]

[ "func", "(", "api", "*", "BaseAPI", ")", "getModelFilters", "(", "filters", "params", ".", "OfferFilters", ")", "(", "models", "map", "[", "string", "]", "Model", ",", "filtersPerModel", "map", "[", "string", "]", "[", "]", "jujucrossmodel", ".", "ApplicationOfferFilter", ",", "_", "error", ",", ")", "{", "models", "=", "make", "(", "map", "[", "string", "]", "Model", ")", "\n", "filtersPerModel", "=", "make", "(", "map", "[", "string", "]", "[", "]", "jujucrossmodel", ".", "ApplicationOfferFilter", ")", "\n\n", "// Group the filters per model and then query each model with the relevant filters", "// for that model.", "modelUUIDs", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "f", ":=", "range", "filters", ".", "Filters", "{", "if", "f", ".", "ModelName", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "(", "modelUUID", "string", "\n", "ok", "bool", "\n", ")", "\n", "if", "modelUUID", ",", "ok", "=", "modelUUIDs", "[", "f", ".", "ModelName", "]", ";", "!", "ok", "{", "var", "err", "error", "\n", "model", ",", "absModelPath", ",", "ok", ",", "err", ":=", "api", ".", "modelForName", "(", "f", ".", "ModelName", ",", "f", ".", "OwnerName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "ok", "{", "err", ":=", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "absModelPath", ")", "\n", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Record the UUID and model for next time.", "modelUUID", "=", "model", ".", "UUID", "(", ")", "\n", "modelUUIDs", "[", "f", ".", "ModelName", "]", "=", "modelUUID", "\n", "models", "[", "modelUUID", "]", "=", "model", "\n", "}", "\n\n", "// Record the filter and model details against the model UUID.", "filters", ":=", "filtersPerModel", "[", "modelUUID", "]", "\n", "filter", ",", "err", ":=", "makeOfferFilterFromParams", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "filters", "=", "append", "(", "filters", ",", "filter", ")", "\n", "filtersPerModel", "[", "modelUUID", "]", "=", "filters", "\n", "}", "\n", "return", "models", ",", "filtersPerModel", ",", "nil", "\n", "}" ]

[ "getModelFilters", "splits", "the", "specified", "filters", "per", "model", "and", "returns", "the", "model", "and", "filter", "details", "for", "each", "." ]

[ "func", "(", "api", "*", "BaseAPI", ")", "getApplicationOffersDetails", "(", "filters", "params", ".", "OfferFilters", ",", "requiredPermission", "permission", ".", "Access", ",", ")", "(", "[", "]", "params", ".", "ApplicationOfferAdminDetails", ",", "error", ")", "{", "// If there are no filters specified, that's an error since the", "// caller is expected to specify at the least one or more models", "// to avoid an unbounded query across all models.", "if", "len", "(", "filters", ".", "Filters", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Gather all the filter details for doing a query for each model.", "models", ",", "filtersPerModel", ",", "err", ":=", "api", ".", "getModelFilters", "(", "filters", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Ensure the result is deterministic.", "var", "allUUIDs", "[", "]", "string", "\n", "for", "modelUUID", ":=", "range", "filtersPerModel", "{", "allUUIDs", "=", "append", "(", "allUUIDs", ",", "modelUUID", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "allUUIDs", ")", "\n\n", "// Do the per model queries.", "var", "result", "[", "]", "params", ".", "ApplicationOfferAdminDetails", "\n", "for", "_", ",", "modelUUID", ":=", "range", "allUUIDs", "{", "filters", ":=", "filtersPerModel", "[", "modelUUID", "]", "\n", "offers", ",", "err", ":=", "api", ".", "applicationOffersFromModel", "(", "modelUUID", ",", "requiredPermission", ",", "filters", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "model", ":=", "models", "[", "modelUUID", "]", "\n\n", "for", "_", ",", "offerDetails", ":=", "range", "offers", "{", "offerDetails", ".", "OfferURL", "=", "jujucrossmodel", ".", "MakeURL", "(", "model", ".", "Owner", "(", ")", ".", "Name", "(", ")", ",", "model", ".", "Name", "(", ")", ",", "offerDetails", ".", "OfferName", ",", "\"", "\"", ")", "\n", "result", "=", "append", "(", "result", ",", "offerDetails", ")", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "getApplicationOffersDetails", "gets", "details", "about", "remote", "applications", "that", "match", "given", "filter", "." ]

[ "func", "NewDirectory", "(", "containerName", "string", ")", "(", "directory", "string", ",", "err", "error", ")", "{", "directory", "=", "dirForName", "(", "containerName", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "directory", ")", "\n", "if", "err", "=", "os", ".", "MkdirAll", "(", "directory", ",", "0755", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "directory", ",", "nil", "\n", "}" ]

[ "NewDirectory", "creates", "a", "new", "directory", "for", "the", "container", "name", "in", "the", "directory", "identified", "by", "ContainerDir", "." ]

[ "func", "RemoveDirectory", "(", "containerName", "string", ")", "error", "{", "// Move the directory.", "logger", ".", "Tracef", "(", "\"", "\"", ",", "RemovedContainerDir", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "RemovedContainerDir", ",", "0755", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "removedDir", ",", "err", ":=", "utils", ".", "UniqueDirectory", "(", "RemovedContainerDir", ",", "containerName", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "if", "err", ":=", "os", ".", "Rename", "(", "dirForName", "(", "containerName", ")", ",", "removedDir", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n\n", "}" ]

[ "RemoveDirectory", "moves", "the", "container", "directory", "from", "ContainerDir", "to", "RemovedContainerDir", "and", "makes", "sure", "that", "the", "names", "don", "t", "clash", "." ]

[ "func", "NewState", "(", "caller", "base", ".", "APICaller", ")", "*", "State", "{", "facadeCaller", ":=", "base", ".", "NewFacadeCaller", "(", "caller", ",", "machinerFacade", ")", "\n", "return", "&", "State", "{", "facade", ":", "facadeCaller", ",", "APIAddresser", ":", "common", ".", "NewAPIAddresser", "(", "facadeCaller", ")", ",", "}", "\n", "}" ]

[ "NewState", "creates", "a", "new", "client", "-", "side", "Machiner", "facade", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "Watch", "(", ")", "(", "watcher", ".", "RelationUnitsWatcher", ",", "error", ")", "{", "return", "ru", ".", "st", ".", "WatchRelationUnits", "(", "ru", ".", "relation", ".", "tag", ",", "ru", ".", "unit", ".", "tag", ")", "\n", "}" ]

[ "Watch", "returns", "a", "watcher", "that", "notifies", "of", "changes", "to", "counterpart", "units", "in", "the", "relation", "." ]

[ "func", "(", "a", "*", "cleanupArg", ")", "SetBSON", "(", "raw", "bson", ".", "Raw", ")", "error", "{", "a", ".", "Value", "=", "raw", "\n", "return", "nil", "\n", "}" ]

[ "SetBSON", "is", "part", "of", "the", "bson", ".", "Setter", "interface", "." ]

[ "func", "newCleanupOp", "(", "kind", "cleanupKind", ",", "prefix", "string", ",", "args", "...", "interface", "{", "}", ")", "txn", ".", "Op", "{", "return", "newCleanupAtOp", "(", "asap", ",", "kind", ",", "prefix", ",", "args", "...", ")", "\n", "}" ]

[ "newCleanupOp", "returns", "a", "txn", ".", "Op", "that", "creates", "a", "cleanup", "document", "with", "a", "unique", "id", "and", "the", "supplied", "kind", "and", "prefix", "." ]

[ "func", "(", "st", "*", "State", ")", "NeedsCleanup", "(", ")", "(", "bool", ",", "error", ")", "{", "cleanups", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "cleanupsC", ")", "\n", "defer", "closer", "(", ")", "\n", "count", ",", "err", ":=", "cleanups", ".", "Count", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "count", ">", "0", ",", "nil", "\n", "}" ]

[ "NeedsCleanup", "returns", "true", "if", "documents", "previously", "marked", "for", "removal", "exist", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupModelsForDyingController", "(", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "(", "err", "error", ")", "{", "var", "args", "DestroyModelParams", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// Old cleanups have no args, so follow the old behaviour.", "destroyStorage", ":=", "true", "\n", "args", ".", "DestroyStorage", "=", "&", "destroyStorage", "\n", "case", "1", ":", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "args", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "modelUUIDs", ",", "err", ":=", "st", ".", "AllModelUUIDs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "modelUUID", ":=", "range", "modelUUIDs", "{", "newSt", ",", "err", ":=", "st", ".", "newStateNoWorkers", "(", "modelUUID", ")", "\n", "// We explicitly don't start the workers.", "if", "err", "!=", "nil", "{", "// This model could have been removed.", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "newSt", ".", "Close", "(", ")", "\n\n", "model", ",", "err", ":=", "newSt", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "model", ".", "Destroy", "(", "args", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupModelsForDyingController", "sets", "all", "models", "to", "dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "controller", "is", "destroyed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupMachinesForDyingModel", "(", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "(", "err", "error", ")", "{", "var", "args", "DestroyModelParams", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// Old cleanups have no args, so follow the old behaviour.", "case", "1", ":", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "args", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "// This won't miss machines, because a Dying model cannot have", "// machines added to it. But we do have to remove the machines themselves", "// via individual transactions, because they could be in any state at all.", "machines", ",", "err", ":=", "st", ".", "AllMachines", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "force", ":=", "args", ".", "Force", "!=", "nil", "&&", "*", "args", ".", "Force", "\n", "for", "_", ",", "m", ":=", "range", "machines", "{", "if", "m", ".", "IsManager", "(", ")", "{", "continue", "\n", "}", "\n", "if", "_", ",", "isContainer", ":=", "m", ".", "ParentId", "(", ")", ";", "isContainer", "{", "continue", "\n", "}", "\n", "manual", ",", "err", ":=", "m", ".", "IsManual", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// TODO (force 2019-4-24) we should not break out here but continue with other machines.", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "manual", "{", "// Manually added machines should never be force-", "// destroyed automatically. That should be a user-", "// driven decision, since it may leak applications", "// and resources on the machine. If something is", "// stuck, then the user can still force-destroy", "// the manual machines.", "if", "err", ":=", "m", ".", "Destroy", "(", ")", ";", "err", "!=", "nil", "{", "// Since we cannot delete a manual machine, we cannot proceed with model destruction even if it is forced.", "// TODO (force 2019-4-24) However, we should not break out here but continue with other machines.", "return", "errors", ".", "Trace", "(", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "m", ".", "Id", "(", ")", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "// TODO (force 2019-04-26) Should this always be ForceDestroy or only when", "// 'destroy-model --force' is specified?...", "if", "err", ":=", "m", ".", "ForceDestroy", "(", "args", ".", "MaxWait", ")", ";", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "m", ".", "Id", "(", ")", ")", "\n", "// TODO (force 2019-4-24) we should not break out here but continue with other machines.", "if", "!", "force", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupMachinesForDyingModel", "sets", "all", "non", "-", "manager", "machines", "to", "Dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "model", "is", "destroyed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupStorageForDyingModel", "(", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "(", "err", "error", ")", "{", "sb", ",", "err", ":=", "NewStorageBackend", "(", "st", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "args", "DestroyModelParams", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// Old cleanups have no args, so follow the old behaviour.", "case", "1", ":", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "args", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n\n", "destroyStorage", ":=", "sb", ".", "DestroyStorageInstance", "\n", "if", "args", ".", "DestroyStorage", "==", "nil", "||", "!", "*", "args", ".", "DestroyStorage", "{", "destroyStorage", "=", "sb", ".", "ReleaseStorageInstance", "\n", "}", "\n\n", "storage", ",", "err", ":=", "sb", ".", "AllStorageInstances", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "force", ":=", "args", ".", "Force", "!=", "nil", "&&", "*", "args", ".", "Force", "\n", "for", "_", ",", "s", ":=", "range", "storage", "{", "const", "destroyAttached", "=", "true", "\n", "err", ":=", "destroyStorage", "(", "s", ".", "StorageTag", "(", ")", ",", "destroyAttached", ",", "force", ",", "args", ".", "MaxWait", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupStorageForDyingModel", "sets", "all", "storage", "to", "Dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "model", "is", "destroyed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupApplication", "(", "applicationname", "string", ",", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "(", "err", "error", ")", "{", "app", ",", "err", ":=", "st", ".", "Application", "(", "applicationname", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "// Nothing to do, the application is already gone.", "logger", ".", "Tracef", "(", "\"", "\"", ",", "applicationname", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "app", ".", "Life", "(", ")", "==", "Alive", "{", "return", "errors", ".", "BadRequestf", "(", "\"", "\"", ",", "applicationname", ")", "\n", "}", "\n", "// We know the app is at least Dying, so check if the unit/relation counts are no longer referencing this application.", "if", "app", ".", "UnitCount", "(", ")", ">", "0", "||", "app", ".", "RelationCount", "(", ")", ">", "0", "{", "// this is considered a no-op because whatever is currently referencing the application", "// should queue up a new cleanup once it stops", "logger", ".", "Tracef", "(", "\"", "\"", ",", "applicationname", ",", "app", ".", "UnitCount", "(", ")", ",", "app", ".", "RelationCount", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n", "destroyStorage", ":=", "false", "\n", "force", ":=", "false", "\n", "if", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "!=", "2", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "destroyStorage", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "cleanupArgs", "[", "1", "]", ".", "Unmarshal", "(", "&", "force", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "op", ":=", "app", ".", "DestroyOperation", "(", ")", "\n", "op", ".", "DestroyStorage", "=", "destroyStorage", "\n", "op", ".", "Force", "=", "force", "\n", "return", "st", ".", "ApplyOperation", "(", "op", ")", "\n", "}" ]

[ "cleanupApplication", "checks", "if", "all", "references", "to", "a", "dying", "application", "have", "been", "removed", "and", "if", "so", "removes", "the", "application", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupApplicationsForDyingModel", "(", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "(", "err", "error", ")", "{", "var", "args", "DestroyModelParams", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// Old cleanups have no args, so follow the old behaviour.", "case", "1", ":", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "args", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "if", "err", ":=", "st", ".", "removeRemoteApplicationsForDyingModel", "(", "args", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "st", ".", "removeApplicationsForDyingModel", "(", "args", ")", "\n", "}" ]

[ "cleanupApplicationsForDyingModel", "sets", "all", "applications", "to", "Dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "model", "is", "destroyed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupUnitsForDyingApplication", "(", "applicationname", "string", ",", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "(", "err", "error", ")", "{", "var", "destroyStorage", "bool", "\n", "destroyStorageArg", ":=", "func", "(", ")", "error", "{", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "destroyStorage", ")", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "var", "force", "bool", "\n", "var", "maxWait", "time", ".", "Duration", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// It's valid to have no args: old cleanups have no args, so follow the old behaviour.", "case", "1", ":", "if", "err", ":=", "destroyStorageArg", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "3", ":", "if", "err", ":=", "destroyStorageArg", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "cleanupArgs", "[", "1", "]", ".", "Unmarshal", "(", "&", "force", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "cleanupArgs", "[", "2", "]", ".", "Unmarshal", "(", "&", "maxWait", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n\n", "// This won't miss units, because a Dying application cannot have units", "// added to it. But we do have to remove the units themselves via", "// individual transactions, because they could be in any state at all.", "units", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "unitsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "unit", ":=", "Unit", "{", "st", ":", "st", "}", "\n", "sel", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "applicationname", "}", ",", "{", "\"", "\"", ",", "Alive", "}", "}", "\n", "iter", ":=", "units", ".", "Find", "(", "sel", ")", ".", "Iter", "(", ")", "\n", "defer", "closeIter", "(", "iter", ",", "&", "err", ",", "\"", "\"", ")", "\n", "for", "iter", ".", "Next", "(", "&", "unit", ".", "doc", ")", "{", "op", ":=", "unit", ".", "DestroyOperation", "(", ")", "\n", "op", ".", "DestroyStorage", "=", "destroyStorage", "\n", "op", ".", "Force", "=", "force", "\n", "op", ".", "MaxWait", "=", "maxWait", "\n", "if", "err", ":=", "st", ".", "ApplyOperation", "(", "op", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupUnitsForDyingApplication", "sets", "all", "units", "with", "the", "given", "prefix", "to", "Dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "application", "is", "destroyed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupDyingUnit", "(", "name", "string", ",", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "error", "{", "var", "destroyStorage", "bool", "\n", "destroyStorageArg", ":=", "func", "(", ")", "error", "{", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "destroyStorage", ")", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "var", "force", "bool", "\n", "var", "maxWait", "time", ".", "Duration", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// It's valid to have no args: old cleanups have no args, so follow the old behaviour.", "case", "1", ":", "if", "err", ":=", "destroyStorageArg", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "3", ":", "if", "err", ":=", "destroyStorageArg", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "cleanupArgs", "[", "1", "]", ".", "Unmarshal", "(", "&", "force", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "cleanupArgs", "[", "2", "]", ".", "Unmarshal", "(", "&", "maxWait", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n\n", "unit", ",", "err", ":=", "st", ".", "Unit", "(", "name", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Mark the unit as departing from its joined relations, allowing", "// related units to start converging to a state in which that unit", "// is gone as quickly as possible.", "relations", ",", "err", ":=", "unit", ".", "RelationsJoined", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "err", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "unit", ".", "Name", "(", ")", ",", "err", ")", "\n", "}", "\n", "for", "_", ",", "relation", ":=", "range", "relations", "{", "relationUnit", ",", "err", ":=", "relation", ".", "Unit", "(", "unit", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "err", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "unit", ".", "Name", "(", ")", ",", "err", ")", "\n", "}", "else", "{", "if", "err", ":=", "relationUnit", ".", "PrepareLeaveScope", "(", ")", ";", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "err", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "relation", ",", "unit", ".", "Name", "(", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// If we're forcing, set up a backstop cleanup to really remove", "// the unit in the case that the unit and machine agents don't for", "// some reason.", "if", "force", "{", "st", ".", "scheduleForceCleanup", "(", "cleanupForceDestroyedUnit", ",", "name", ",", "maxWait", ")", "\n", "}", "\n\n", "if", "destroyStorage", "{", "// Detach and mark storage instances as dying, allowing the", "// unit to terminate.", "return", "st", ".", "cleanupUnitStorageInstances", "(", "unit", ".", "UnitTag", "(", ")", ",", "force", ",", "maxWait", ")", "\n", "}", "else", "{", "// Mark storage attachments as dying, so that they are detached", "// and removed from state, allowing the unit to terminate.", "return", "st", ".", "cleanupUnitStorageAttachments", "(", "unit", ".", "UnitTag", "(", ")", ",", "false", ",", "force", ",", "maxWait", ")", "\n", "}", "\n", "}" ]

[ "cleanupDyingUnit", "marks", "resources", "owned", "by", "the", "unit", "as", "dying", "to", "ensure", "they", "are", "cleaned", "up", "as", "well", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupRemovedUnit", "(", "unitId", "string", ",", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "error", "{", "var", "force", "bool", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// Old cleanups have no args, so follow the old behaviour.", "case", "1", ":", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "force", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n\n", "actions", ",", "err", ":=", "st", ".", "matchingActionsByReceiverId", "(", "unitId", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "unitId", ",", "err", ")", "\n", "}", "\n", "cancelled", ":=", "ActionResults", "{", "Status", ":", "ActionCancelled", ",", "Message", ":", "\"", "\"", ",", "}", "\n", "for", "_", ",", "action", ":=", "range", "actions", "{", "switch", "action", ".", "Status", "(", ")", "{", "case", "ActionCompleted", ",", "ActionCancelled", ",", "ActionFailed", ":", "// nothing to do here", "default", ":", "if", "_", ",", "err", "=", "action", ".", "Finish", "(", "cancelled", ")", ";", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "action", ".", "Name", "(", ")", ",", "unitId", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "change", ":=", "payloadCleanupChange", "{", "Unit", ":", "unitId", ",", "}", "\n", "if", "err", ":=", "Apply", "(", "st", ".", "database", ",", "change", ")", ";", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "unitId", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupRemovedUnit", "takes", "care", "of", "all", "the", "final", "cleanup", "required", "when", "a", "unit", "is", "removed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupDyingMachine", "(", "machineId", "string", ",", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "error", "{", "var", "force", "bool", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// Old cleanups have no args, so follow the old behaviour.", "case", "1", ":", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "force", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "machine", ",", "err", ":=", "st", ".", "Machine", "(", "machineId", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "cleanupDyingMachineResources", "(", "machine", ",", "force", ")", "\n", "}" ]

[ "cleanupDyingMachine", "marks", "resources", "owned", "by", "the", "machine", "as", "dying", "to", "ensure", "they", "are", "cleaned", "up", "as", "well", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupContainers", "(", "machine", "*", "Machine", ",", "maxWait", "time", ".", "Duration", ")", "error", "{", "containerIds", ",", "err", ":=", "machine", ".", "Containers", "(", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "containerId", ":=", "range", "containerIds", "{", "if", "err", ":=", "st", ".", "cleanupForceDestroyedMachineInternal", "(", "containerId", ",", "maxWait", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "container", ",", "err", ":=", "st", ".", "Machine", "(", "containerId", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "container", ".", "Remove", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupContainers", "recursively", "calls", "cleanupForceDestroyedMachine", "on", "the", "supplied", "machine", "s", "containers", "and", "removes", "them", "from", "state", "entirely", "." ]

[ "func", "(", "st", "*", "State", ")", "obliterateUnit", "(", "unitName", "string", ",", "force", "bool", ",", "maxWait", "time", ".", "Duration", ")", "(", "[", "]", "error", ",", "error", ")", "{", "var", "opErrs", "[", "]", "error", "\n", "unit", ",", "err", ":=", "st", ".", "Unit", "(", "unitName", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "opErrs", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "opErrs", ",", "err", "\n", "}", "\n", "// Unlike the machine, we *can* always destroy the unit, and (at least)", "// prevent further dependencies being added. If we're really lucky, the", "// unit will be removed immediately.", "errs", ",", "err", ":=", "unit", ".", "DestroyWithForce", "(", "force", ",", "maxWait", ")", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "errs", "...", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "opErrs", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "unitName", ")", "\n", "}", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "unit", ".", "Refresh", "(", ")", ";", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "opErrs", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "opErrs", ",", "err", "\n", "}", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "err", ")", "\n", "}", "\n", "// Destroy and remove all storage attachments for the unit.", "if", "err", ":=", "st", ".", "cleanupUnitStorageAttachments", "(", "unit", ".", "UnitTag", "(", ")", ",", "true", ",", "force", ",", "maxWait", ")", ";", "err", "!=", "nil", "{", "err", ":=", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "unitName", ")", "\n", "if", "!", "force", "{", "return", "opErrs", ",", "err", "\n", "}", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "err", ")", "\n", "}", "\n", "for", "_", ",", "subName", ":=", "range", "unit", ".", "SubordinateNames", "(", ")", "{", "errs", ",", "err", ":=", "st", ".", "obliterateUnit", "(", "subName", ",", "force", ",", "maxWait", ")", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "errs", "...", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "opErrs", ",", "err", "\n", "}", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "unit", ".", "EnsureDead", "(", ")", ";", "err", "!=", "nil", "{", "if", "!", "force", "{", "return", "opErrs", ",", "err", "\n", "}", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "err", ")", "\n", "}", "\n", "errs", ",", "err", "=", "unit", ".", "RemoveWithForce", "(", "force", ",", "maxWait", ")", "\n", "opErrs", "=", "append", "(", "opErrs", ",", "errs", "...", ")", "\n", "return", "opErrs", ",", "err", "\n", "}" ]

[ "obliterateUnit", "removes", "a", "unit", "from", "state", "completely", ".", "It", "is", "not", "safe", "or", "sane", "to", "obliterate", "any", "unit", "in", "isolation", ";", "its", "only", "reasonable", "use", "is", "in", "the", "context", "of", "machine", "obliteration", "in", "which", "we", "can", "be", "sure", "that", "unclean", "shutdown", "of", "units", "is", "not", "going", "to", "leave", "a", "machine", "in", "a", "difficult", "state", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupAttachmentsForDyingStorage", "(", "storageId", "string", ",", "cleanupArgs", "[", "]", "bson", ".", "Raw", ")", "(", "err", "error", ")", "{", "var", "force", "bool", "\n", "var", "maxWait", "time", ".", "Duration", "\n", "switch", "n", ":=", "len", "(", "cleanupArgs", ")", ";", "n", "{", "case", "0", ":", "// It's valid to have no args: old cleanups have no args, so follow the old behaviour.", "case", "2", ":", "if", "err", ":=", "cleanupArgs", "[", "0", "]", ".", "Unmarshal", "(", "&", "force", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "cleanupArgs", "[", "1", "]", ".", "Unmarshal", "(", "&", "maxWait", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n\n", "sb", ",", "err", ":=", "NewStorageBackend", "(", "st", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "storageTag", ":=", "names", ".", "NewStorageTag", "(", "storageId", ")", "\n\n", "// This won't miss attachments, because a Dying storage instance cannot", "// have attachments added to it. But we do have to remove the attachments", "// themselves via individual transactions, because they could be in", "// any state at all.", "coll", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "storageAttachmentsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "doc", "storageAttachmentDoc", "\n", "fields", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "\n", "iter", ":=", "coll", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "storageId", "}", "}", ")", ".", "Select", "(", "fields", ")", ".", "Iter", "(", ")", "\n", "defer", "closeIter", "(", "iter", ",", "&", "err", ",", "\"", "\"", ")", "\n", "var", "detachErr", "error", "\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "unitTag", ":=", "names", ".", "NewUnitTag", "(", "doc", ".", "Unit", ")", "\n", "if", "err", ":=", "sb", ".", "DetachStorage", "(", "storageTag", ",", "unitTag", ",", "force", ",", "maxWait", ")", ";", "err", "!=", "nil", "{", "detachErr", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "detachErr", ")", "\n", "}", "\n", "}", "\n", "if", "!", "force", "&&", "detachErr", "!=", "nil", "{", "return", "detachErr", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupAttachmentsForDyingStorage", "sets", "all", "storage", "attachments", "related", "to", "the", "specified", "storage", "instance", "to", "Dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "storage", "instance", "is", "destroyed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupAttachmentsForDyingVolume", "(", "volumeId", "string", ")", "(", "err", "error", ")", "{", "volumeTag", ":=", "names", ".", "NewVolumeTag", "(", "volumeId", ")", "\n\n", "// This won't miss attachments, because a Dying volume cannot have", "// attachments added to it. But we do have to remove the attachments", "// themselves via individual transactions, because they could be in", "// any state at all.", "coll", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "volumeAttachmentsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "sb", ",", "err", ":=", "NewStorageBackend", "(", "st", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "var", "doc", "volumeAttachmentDoc", "\n", "fields", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "\n", "iter", ":=", "coll", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "volumeId", "}", "}", ")", ".", "Select", "(", "fields", ")", ".", "Iter", "(", ")", "\n", "defer", "closeIter", "(", "iter", ",", "&", "err", ",", "\"", "\"", ")", "\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "hostTag", ":=", "storageAttachmentHost", "(", "doc", ".", "Host", ")", "\n", "if", "err", ":=", "sb", ".", "DetachVolume", "(", "hostTag", ",", "volumeTag", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupAttachmentsForDyingVolume", "sets", "all", "volume", "attachments", "related", "to", "the", "specified", "volume", "to", "Dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "volume", "is", "destroyed", "." ]

[ "func", "(", "st", "*", "State", ")", "cleanupAttachmentsForDyingFilesystem", "(", "filesystemId", "string", ")", "(", "err", "error", ")", "{", "sb", ",", "err", ":=", "NewStorageBackend", "(", "st", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "filesystemTag", ":=", "names", ".", "NewFilesystemTag", "(", "filesystemId", ")", "\n\n", "// This won't miss attachments, because a Dying filesystem cannot have", "// attachments added to it. But we do have to remove the attachments", "// themselves via individual transactions, because they could be in", "// any state at all.", "coll", ",", "closer", ":=", "sb", ".", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "filesystemAttachmentsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "doc", "filesystemAttachmentDoc", "\n", "fields", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "\n", "iter", ":=", "coll", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "filesystemId", "}", "}", ")", ".", "Select", "(", "fields", ")", ".", "Iter", "(", ")", "\n", "defer", "closeIter", "(", "iter", ",", "&", "err", ",", "\"", "\"", ")", "\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "hostTag", ":=", "storageAttachmentHost", "(", "doc", ".", "Host", ")", "\n", "if", "err", ":=", "sb", ".", "DetachFilesystem", "(", "hostTag", ",", "filesystemTag", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanupAttachmentsForDyingFilesystem", "sets", "all", "filesystem", "attachments", "related", "to", "the", "specified", "filesystem", "to", "Dying", "if", "they", "are", "not", "already", "Dying", "or", "Dead", ".", "It", "s", "expected", "to", "be", "used", "when", "a", "filesystem", "is", "destroyed", "." ]

[ "func", "(", "m", "MacaroonCache", ")", "Set", "(", "u", "*", "charm", ".", "URL", ",", "ms", "macaroon", ".", "Slice", ")", "error", "{", "c", ",", "err", ":=", "m", ".", "Charm", "(", "u", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "c", ".", "UpdateMacaroon", "(", "ms", ")", "\n", "}" ]

[ "Set", "stores", "the", "macaroon", "on", "the", "charm", "." ]

[ "func", "insertCharmOps", "(", "mb", "modelBackend", ",", "info", "CharmInfo", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "if", "info", ".", "ID", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "doc", ":=", "charmDoc", "{", "DocID", ":", "info", ".", "ID", ".", "String", "(", ")", ",", "URL", ":", "info", ".", "ID", ",", "CharmVersion", ":", "info", ".", "Version", ",", "Meta", ":", "info", ".", "Charm", ".", "Meta", "(", ")", ",", "Config", ":", "safeConfig", "(", "info", ".", "Charm", ")", ",", "Metrics", ":", "info", ".", "Charm", ".", "Metrics", "(", ")", ",", "Actions", ":", "info", ".", "Charm", ".", "Actions", "(", ")", ",", "BundleSha256", ":", "info", ".", "SHA256", ",", "StoragePath", ":", "info", ".", "StoragePath", ",", "}", "\n", "lpc", ",", "ok", ":=", "info", ".", "Charm", ".", "(", "charm", ".", "LXDProfiler", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "doc", ".", "LXDProfile", "=", "safeLXDProfile", "(", "lpc", ".", "LXDProfile", "(", ")", ")", "\n\n", "if", "err", ":=", "checkCharmDataIsStorable", "(", "doc", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "info", ".", "Macaroon", "!=", "nil", "{", "mac", ",", "err", ":=", "info", ".", "Macaroon", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "doc", ".", "Macaroon", "=", "mac", "\n", "}", "\n", "return", "insertAnyCharmOps", "(", "mb", ",", "&", "doc", ")", "\n", "}" ]

[ "insertCharmOps", "returns", "the", "txn", "operations", "necessary", "to", "insert", "the", "supplied", "charm", "data", ".", "If", "curl", "is", "nil", "an", "error", "will", "be", "returned", "." ]

[ "func", "insertPlaceholderCharmOps", "(", "mb", "modelBackend", ",", "curl", "*", "charm", ".", "URL", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "if", "curl", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "insertAnyCharmOps", "(", "mb", ",", "&", "charmDoc", "{", "DocID", ":", "curl", ".", "String", "(", ")", ",", "URL", ":", "curl", ",", "Placeholder", ":", "true", ",", "}", ")", "\n", "}" ]

[ "insertPlaceholderCharmOps", "returns", "the", "txn", "operations", "necessary", "to", "insert", "a", "charm", "document", "referencing", "a", "store", "charm", "that", "is", "not", "yet", "directly", "accessible", "within", "the", "model", ".", "If", "curl", "is", "nil", "an", "error", "will", "be", "returned", "." ]

[ "func", "insertAnyCharmOps", "(", "mb", "modelBackend", ",", "cdoc", "*", "charmDoc", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "charms", ",", "closer", ":=", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "charmsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "life", ",", "err", ":=", "nsLife", ".", "read", "(", "charms", ",", "cdoc", ".", "DocID", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "// everything is as it should be", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "else", "if", "life", "==", "Dead", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "charmOp", ":=", "txn", ".", "Op", "{", "C", ":", "charmsC", ",", "Id", ":", "cdoc", ".", "DocID", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "cdoc", ",", "}", "\n\n", "refcounts", ",", "closer", ":=", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "refcountsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "charmKey", ":=", "charmGlobalKey", "(", "cdoc", ".", "URL", ")", "\n", "refOp", ",", "required", ",", "err", ":=", "nsRefcounts", ".", "LazyCreateOp", "(", "refcounts", ",", "charmKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "else", "if", "required", "{", "return", "[", "]", "txn", ".", "Op", "{", "refOp", ",", "charmOp", "}", ",", "nil", "\n", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "charmOp", "}", ",", "nil", "\n", "}" ]

[ "insertAnyCharmOps", "returns", "the", "txn", "operations", "necessary", "to", "insert", "the", "supplied", "charm", "document", "." ]

[ "func", "updateCharmOps", "(", "mb", "modelBackend", ",", "info", "CharmInfo", ",", "assert", "bson", ".", "D", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "charms", ",", "closer", ":=", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "charmsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "charmKey", ":=", "info", ".", "ID", ".", "String", "(", ")", "\n", "op", ",", "err", ":=", "nsLife", ".", "aliveOp", "(", "charms", ",", "charmKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "lifeAssert", ",", "ok", ":=", "op", ".", "Assert", ".", "(", "bson", ".", "D", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "op", ".", "Assert", ")", "\n", "}", "\n", "op", ".", "Assert", "=", "append", "(", "lifeAssert", ",", "assert", "...", ")", "\n\n", "data", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "info", ".", "Version", "}", ",", "{", "\"", "\"", ",", "info", ".", "Charm", ".", "Meta", "(", ")", "}", ",", "{", "\"", "\"", ",", "safeConfig", "(", "info", ".", "Charm", ")", "}", ",", "{", "\"", "\"", ",", "info", ".", "Charm", ".", "Actions", "(", ")", "}", ",", "{", "\"", "\"", ",", "info", ".", "Charm", ".", "Metrics", "(", ")", "}", ",", "{", "\"", "\"", ",", "info", ".", "StoragePath", "}", ",", "{", "\"", "\"", ",", "info", ".", "SHA256", "}", ",", "{", "\"", "\"", ",", "false", "}", ",", "{", "\"", "\"", ",", "false", "}", ",", "}", "\n\n", "lpc", ",", "ok", ":=", "info", ".", "Charm", ".", "(", "charm", ".", "LXDProfiler", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "data", "=", "append", "(", "data", ",", "bson", ".", "DocElem", "{", "\"", "\"", ",", "safeLXDProfile", "(", "lpc", ".", "LXDProfile", "(", ")", ")", "}", ")", "\n\n", "if", "err", ":=", "checkCharmDataIsStorable", "(", "data", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "len", "(", "info", ".", "Macaroon", ")", ">", "0", "{", "mac", ",", "err", ":=", "info", ".", "Macaroon", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "data", "=", "append", "(", "data", ",", "bson", ".", "DocElem", "{", "\"", "\"", ",", "mac", "}", ")", "\n", "}", "\n\n", "op", ".", "Update", "=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "data", "}", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "op", "}", ",", "nil", "\n", "}" ]

[ "updateCharmOps", "returns", "the", "txn", "operations", "necessary", "to", "update", "the", "charm", "document", "with", "the", "supplied", "data", "so", "long", "as", "the", "supplied", "assert", "still", "holds", "true", "." ]

[ "func", "convertPlaceholderCharmOps", "(", "docID", "string", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "return", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "charmsC", ",", "Id", ":", "docID", ",", "Assert", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "{", "\"", "\"", ",", "false", "}", ",", "{", "\"", "\"", ",", "true", "}", ",", "}", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "true", "}", ",", "{", "\"", "\"", ",", "false", "}", ",", "}", "}", "}", ",", "}", "}", ",", "nil", "\n\n", "}" ]

[ "convertPlaceholderCharmOps", "returns", "the", "txn", "operations", "necessary", "to", "convert", "the", "charm", "with", "the", "supplied", "docId", "from", "a", "placeholder", "to", "one", "marked", "for", "pending", "upload", "." ]

[ "func", "deleteOldPlaceholderCharmsOps", "(", "mb", "modelBackend", ",", "charms", "mongo", ".", "Collection", ",", "curl", "*", "charm", ".", "URL", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "// Get a regex with the charm URL and no revision.", "noRevURL", ":=", "curl", ".", "WithRevision", "(", "-", "1", ")", "\n", "curlRegex", ":=", "\"", "\"", "+", "regexp", ".", "QuoteMeta", "(", "mb", ".", "docID", "(", "noRevURL", ".", "String", "(", ")", ")", ")", "\n\n", "var", "docs", "[", "]", "charmDoc", "\n", "query", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "curlRegex", "}", "}", "}", ",", "{", "\"", "\"", ",", "true", "}", "}", "\n", "err", ":=", "charms", ".", "Find", "(", "query", ")", ".", "Select", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", ",", "{", "\"", "\"", ",", "1", "}", "}", ")", ".", "All", "(", "&", "docs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "refcounts", ",", "closer", ":=", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "refcountsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "ops", "[", "]", "txn", ".", "Op", "\n", "for", "_", ",", "doc", ":=", "range", "docs", "{", "if", "doc", ".", "URL", ".", "Revision", ">=", "curl", ".", "Revision", "{", "continue", "\n", "}", "\n", "key", ":=", "charmGlobalKey", "(", "doc", ".", "URL", ")", "\n", "refOp", ",", "err", ":=", "nsRefcounts", ".", "RemoveOp", "(", "refcounts", ",", "key", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "refOp", ",", "txn", ".", "Op", "{", "C", ":", "charms", ".", "Name", "(", ")", ",", "Id", ":", "doc", ".", "DocID", ",", "Assert", ":", "stillPlaceholder", ",", "Remove", ":", "true", ",", "}", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}" ]

[ "deleteOldPlaceholderCharmsOps", "returns", "the", "txn", "ops", "required", "to", "delete", "all", "placeholder", "charm", "records", "older", "than", "the", "specified", "charm", "URL", "." ]

[ "func", "safeLXDProfile", "(", "profile", "*", "charm", ".", "LXDProfile", ")", "*", "charm", ".", "LXDProfile", "{", "if", "profile", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "escapedProfile", ":=", "charm", ".", "NewLXDProfile", "(", ")", "\n", "escapedProfile", ".", "Description", "=", "profile", ".", "Description", "\n", "// we know the size and shape of the type, so let's use EscapeKey", "escapedConfig", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "profile", ".", "Config", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "profile", ".", "Config", "{", "escapedConfig", "[", "mongoutils", ".", "EscapeKey", "(", "k", ")", "]", "=", "v", "\n", "}", "\n", "escapedProfile", ".", "Config", "=", "escapedConfig", "\n", "// this is more easy to reason about than using mongoutils.EscapeKeys, which", "// requires looping from map[string]interface{} -> map[string]map[string]string", "escapedDevices", ":=", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "string", ",", "len", "(", "profile", ".", "Devices", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "profile", ".", "Devices", "{", "nested", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "v", ")", ")", "\n", "for", "vk", ",", "vv", ":=", "range", "v", "{", "nested", "[", "mongoutils", ".", "EscapeKey", "(", "vk", ")", "]", "=", "vv", "\n", "}", "\n", "escapedDevices", "[", "mongoutils", ".", "EscapeKey", "(", "k", ")", "]", "=", "nested", "\n", "}", "\n", "escapedProfile", ".", "Devices", "=", "escapedDevices", "\n", "return", "escapedProfile", "\n", "}" ]

[ "safeLXDProfile", "ensures", "that", "the", "LXDProfile", "that", "we", "put", "into", "the", "mongo", "data", "store", "can", "in", "fact", "store", "the", "profile", "safely", "by", "escaping", "mongo", "-", "significant", "characters", "in", "config", "options", "." ]

[ "func", "unescapeLXDProfile", "(", "profile", "*", "charm", ".", "LXDProfile", ")", "*", "charm", ".", "LXDProfile", "{", "if", "profile", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "unescapedProfile", ":=", "charm", ".", "NewLXDProfile", "(", ")", "\n", "unescapedProfile", ".", "Description", "=", "profile", ".", "Description", "\n", "// we know the size and shape of the type, so let's use UnescapeKey", "unescapedConfig", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "profile", ".", "Config", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "profile", ".", "Config", "{", "unescapedConfig", "[", "mongoutils", ".", "UnescapeKey", "(", "k", ")", "]", "=", "v", "\n", "}", "\n", "unescapedProfile", ".", "Config", "=", "unescapedConfig", "\n", "// this is more easy to reason about than using mongoutils.UnescapeKeys, which", "// requires looping from map[string]interface{} -> map[string]map[string]string", "unescapedDevices", ":=", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "string", ",", "len", "(", "profile", ".", "Devices", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "profile", ".", "Devices", "{", "nested", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "v", ")", ")", "\n", "for", "vk", ",", "vv", ":=", "range", "v", "{", "nested", "[", "mongoutils", ".", "UnescapeKey", "(", "vk", ")", "]", "=", "vv", "\n", "}", "\n", "unescapedDevices", "[", "mongoutils", ".", "UnescapeKey", "(", "k", ")", "]", "=", "nested", "\n", "}", "\n", "unescapedProfile", ".", "Devices", "=", "unescapedDevices", "\n", "return", "unescapedProfile", "\n", "}" ]

[ "unescapeLXDProfile", "returns", "the", "LXDProfile", "back", "to", "normal", "after", "reading", "from", "state", "." ]

[ "func", "(", "c", "*", "Charm", ")", "Tag", "(", ")", "names", ".", "Tag", "{", "return", "names", ".", "NewCharmTag", "(", "c", ".", "URL", "(", ")", ".", "String", "(", ")", ")", "\n", "}" ]

[ "Tag", "returns", "a", "tag", "identifying", "the", "charm", ".", "Implementing", "state", ".", "GlobalEntity", "interface", "." ]

[ "func", "(", "c", "*", "Charm", ")", "Refresh", "(", ")", "error", "{", "ch", ",", "err", ":=", "c", ".", "st", ".", "Charm", "(", "c", ".", "doc", ".", "URL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "c", ".", "doc", "=", "ch", ".", "doc", "\n", "return", "nil", "\n", "}" ]

[ "Refresh", "loads", "fresh", "charm", "data", "from", "the", "database", ".", "In", "practice", "the", "only", "observable", "change", "should", "be", "to", "its", "Life", "value", "." ]

[ "func", "(", "c", "*", "Charm", ")", "Destroy", "(", ")", "error", "{", "buildTxn", ":=", "func", "(", "_", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "ops", ",", "err", ":=", "charmDestroyOps", "(", "c", ".", "st", ",", "c", ".", "doc", ".", "URL", ")", "\n", "if", "IsNotAlive", "(", "err", ")", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "if", "err", ":=", "c", ".", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "c", ".", "doc", ".", "Life", "=", "Dying", "\n", "return", "nil", "\n", "}" ]

[ "Destroy", "sets", "the", "charm", "to", "Dying", "and", "prevents", "it", "from", "being", "used", "by", "applications", "or", "units", ".", "It", "only", "works", "on", "local", "charms", "and", "only", "when", "the", "charm", "is", "not", "referenced", "by", "any", "application", "." ]

[ "func", "(", "c", "*", "Charm", ")", "URL", "(", ")", "*", "charm", ".", "URL", "{", "clone", ":=", "*", "c", ".", "doc", ".", "URL", "\n", "return", "&", "clone", "\n", "}" ]

[ "URL", "returns", "the", "URL", "that", "identifies", "the", "charm", "." ]

[ "func", "(", "c", "*", "Charm", ")", "Macaroon", "(", ")", "(", "macaroon", ".", "Slice", ",", "error", ")", "{", "if", "len", "(", "c", ".", "doc", ".", "Macaroon", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "var", "m", "macaroon", ".", "Slice", "\n", "if", "err", ":=", "m", ".", "UnmarshalBinary", "(", "c", ".", "doc", ".", "Macaroon", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "m", ",", "nil", "\n", "}" ]

[ "Macaroon", "return", "the", "macaroon", "that", "can", "be", "used", "to", "request", "data", "about", "the", "charm", "from", "the", "charmstore", "or", "nil", "if", "the", "charm", "is", "not", "private", "." ]

[ "func", "(", "c", "*", "Charm", ")", "UpdateMacaroon", "(", "m", "macaroon", ".", "Slice", ")", "error", "{", "info", ":=", "CharmInfo", "{", "Charm", ":", "c", ",", "ID", ":", "c", ".", "URL", "(", ")", ",", "StoragePath", ":", "c", ".", "StoragePath", "(", ")", ",", "SHA256", ":", "c", ".", "BundleSha256", "(", ")", ",", "Macaroon", ":", "m", ",", "}", "\n", "ops", ",", "err", ":=", "updateCharmOps", "(", "c", ".", "st", ",", "info", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "c", ".", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "UpdateMacaroon", "updates", "the", "stored", "macaroon", "for", "this", "charm", "." ]

[ "func", "(", "st", "*", "State", ")", "AddCharm", "(", "info", "CharmInfo", ")", "(", "stch", "*", "Charm", ",", "err", "error", ")", "{", "charms", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "charmsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "if", "err", ":=", "validateCharmVersion", "(", "info", ".", "Charm", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "validateCharmSeries", "(", "model", ".", "Type", "(", ")", ",", "info", ".", "ID", ".", "Series", ",", "info", ".", "Charm", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "query", ":=", "charms", ".", "FindId", "(", "info", ".", "ID", ".", "String", "(", ")", ")", ".", "Select", "(", "bson", ".", "M", "{", "\"", "\"", ":", "1", ",", "\"", "\"", ":", "1", ",", "}", ")", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "var", "doc", "charmDoc", "\n", "if", "err", ":=", "query", ".", "One", "(", "&", "doc", ")", ";", "err", "==", "mgo", ".", "ErrNotFound", "{", "if", "info", ".", "ID", ".", "Schema", "==", "\"", "\"", "{", "curl", ",", "err", ":=", "st", ".", "PrepareLocalCharmUpload", "(", "info", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "info", ".", "ID", "=", "curl", "\n", "return", "updateCharmOps", "(", "st", ",", "info", ",", "stillPending", ")", "\n", "}", "\n", "return", "insertCharmOps", "(", "st", ",", "info", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "else", "if", "doc", ".", "PendingUpload", "{", "return", "updateCharmOps", "(", "st", ",", "info", ",", "stillPending", ")", "\n", "}", "else", "if", "doc", ".", "Placeholder", "{", "return", "updateCharmOps", "(", "st", ",", "info", ",", "stillPlaceholder", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "AlreadyExistsf", "(", "\"", "\"", ",", "info", ".", "ID", ")", "\n", "}", "\n", "if", "err", "=", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ";", "err", "==", "nil", "{", "return", "st", ".", "Charm", "(", "info", ".", "ID", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "AddCharm", "adds", "the", "ch", "charm", "with", "curl", "to", "the", "state", ".", "On", "success", "the", "newly", "added", "charm", "state", "is", "returned", "." ]

[ "func", "(", "st", "*", "State", ")", "AllCharms", "(", ")", "(", "[", "]", "*", "Charm", ",", "error", ")", "{", "charmsCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "charmsC", ")", "\n", "defer", "closer", "(", ")", "\n", "var", "cdoc", "charmDoc", "\n", "var", "charms", "[", "]", "*", "Charm", "\n", "iter", ":=", "charmsCollection", ".", "Find", "(", "nsLife", ".", "notDead", "(", ")", ")", ".", "Iter", "(", ")", "\n", "for", "iter", ".", "Next", "(", "&", "cdoc", ")", "{", "ch", ":=", "newCharm", "(", "st", ",", "&", "cdoc", ")", "\n", "charms", "=", "append", "(", "charms", ",", "ch", ")", "\n", "}", "\n", "return", "charms", ",", "errors", ".", "Trace", "(", "iter", ".", "Close", "(", ")", ")", "\n", "}" ]

[ "AllCharms", "returns", "all", "charms", "in", "state", "." ]

[ "func", "(", "st", "*", "State", ")", "Charm", "(", "curl", "*", "charm", ".", "URL", ")", "(", "*", "Charm", ",", "error", ")", "{", "charms", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "charmsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "cdoc", ":=", "&", "charmDoc", "{", "}", "\n", "what", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "curl", ".", "String", "(", ")", "}", ",", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "true", "}", "}", "}", ",", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "true", "}", "}", "}", ",", "}", "\n", "what", "=", "append", "(", "what", ",", "nsLife", ".", "notDead", "(", ")", "...", ")", "\n", "err", ":=", "charms", ".", "Find", "(", "what", ")", ".", "One", "(", "&", "cdoc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "curl", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "curl", ")", "\n", "}", "\n", "if", "err", ":=", "cdoc", ".", "Meta", ".", "Check", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "newCharm", "(", "st", ",", "cdoc", ")", ",", "nil", "\n", "}" ]

[ "Charm", "returns", "the", "charm", "with", "the", "given", "URL", ".", "Charms", "pending", "upload", "to", "storage", "and", "placeholders", "are", "never", "returned", "." ]

[ "func", "(", "st", "*", "State", ")", "PrepareLocalCharmUpload", "(", "curl", "*", "charm", ".", "URL", ")", "(", "chosenURL", "*", "charm", ".", "URL", ",", "err", "error", ")", "{", "// Perform a few sanity checks first.", "if", "curl", ".", "Schema", "!=", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "curl", ")", "\n", "}", "\n", "if", "curl", ".", "Revision", "<", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "curl", ")", "\n", "}", "\n\n", "revisionSeq", ":=", "charmRevSeqName", "(", "curl", ".", "WithRevision", "(", "-", "1", ")", ".", "String", "(", ")", ")", "\n", "revision", ",", "err", ":=", "sequenceWithMin", "(", "st", ",", "revisionSeq", ",", "curl", ".", "Revision", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "allocatedURL", ":=", "curl", ".", "WithRevision", "(", "revision", ")", "\n\n", "ops", ",", "err", ":=", "insertPendingCharmOps", "(", "st", ",", "allocatedURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "allocatedURL", ",", "nil", "\n", "}" ]

[ "PrepareLocalCharmUpload", "must", "be", "called", "before", "a", "local", "charm", "is", "uploaded", "to", "the", "provider", "storage", "in", "order", "to", "create", "a", "charm", "document", "in", "state", ".", "It", "returns", "the", "chosen", "unique", "charm", "URL", "reserved", "in", "state", "for", "the", "charm", ".", "The", "url", "s", "schema", "must", "be", "local", "and", "it", "must", "include", "a", "revision", "." ]

[ "func", "(", "st", "*", "State", ")", "AddStoreCharmPlaceholder", "(", "curl", "*", "charm", ".", "URL", ")", "(", "err", "error", ")", "{", "// Perform sanity checks first.", "if", "curl", ".", "Schema", "!=", "\"", "\"", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "curl", ")", "\n", "}", "\n", "if", "curl", ".", "Revision", "<", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "curl", ")", "\n", "}", "\n", "charms", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "charmsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "// See if the charm already exists in state and exit early if that's the case.", "var", "doc", "charmDoc", "\n", "err", ":=", "charms", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "curl", ".", "String", "(", ")", "}", "}", ")", ".", "Select", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", ")", ".", "One", "(", "&", "doc", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", "==", "nil", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n\n", "// Delete all previous placeholders so we don't fill up the database with unused data.", "deleteOps", ",", "err", ":=", "deleteOldPlaceholderCharmsOps", "(", "st", ",", "charms", ",", "curl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "insertOps", ",", "err", ":=", "insertPlaceholderCharmOps", "(", "st", ",", "curl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", ":=", "append", "(", "deleteOps", ",", "insertOps", "...", ")", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "st", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ")", "\n", "}" ]

[ "AddStoreCharmPlaceholder", "creates", "a", "charm", "document", "in", "state", "for", "the", "given", "charm", "URL", "which", "must", "reference", "a", "charm", "from", "the", "store", ".", "The", "charm", "document", "is", "marked", "as", "a", "placeholder", "which", "means", "that", "if", "the", "charm", "is", "to", "be", "deployed", "it", "will", "need", "to", "first", "be", "uploaded", "to", "model", "storage", "." ]

[ "func", "Download", "(", "target", "DownloadTarget", ",", "remote", "ContentSource", ")", "error", "{", "resDir", ",", "err", ":=", "target", ".", "Initialize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "resDir", ".", "Write", "(", "remote", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Download", "downloads", "the", "resource", "from", "the", "provied", "source", "to", "the", "target", "." ]

[ "func", "NewCredentials", "(", "values", "map", "[", "string", "]", "string", ")", "(", "*", "Credentials", ",", "error", ")", "{", "var", "creds", "Credentials", "\n", "for", "k", ",", "v", ":=", "range", "values", "{", "switch", "k", "{", "case", "OSEnvClientID", ":", "creds", ".", "ClientID", "=", "v", "\n", "case", "OSEnvClientEmail", ":", "creds", ".", "ClientEmail", "=", "v", "\n", "case", "OSEnvProjectID", ":", "creds", ".", "ProjectID", "=", "v", "\n", "case", "OSEnvPrivateKey", ":", "creds", ".", "PrivateKey", "=", "[", "]", "byte", "(", "v", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "creds", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "jk", ",", "err", ":=", "creds", ".", "buildJSONKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "creds", ".", "JSONKey", "=", "jk", "\n", "return", "&", "creds", ",", "nil", "\n", "}" ]

[ "NewCredentials", "returns", "a", "new", "Credentials", "based", "on", "the", "provided", "values", ".", "The", "keys", "must", "be", "recognized", "OS", "env", "var", "names", "for", "the", "different", "credential", "fields", "." ]

[ "func", "ParseJSONKey", "(", "jsonKeyFile", "io", ".", "Reader", ")", "(", "*", "Credentials", ",", "error", ")", "{", "jsonKey", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "jsonKeyFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "values", ",", "err", ":=", "parseJSONKey", "(", "jsonKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "creds", ",", "err", ":=", "NewCredentials", "(", "values", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "creds", ".", "JSONKey", "=", "jsonKey", "\n", "return", "creds", ",", "nil", "\n", "}" ]

[ "ParseJSONKey", "returns", "a", "new", "Credentials", "with", "values", "based", "on", "the", "provided", "JSON", "key", "file", "contents", "." ]

[ "func", "(", "gc", "Credentials", ")", "buildJSONKey", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "json", ".", "Marshal", "(", "&", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "jsonKeyTypeServiceAccount", ",", "\"", "\"", ":", "gc", ".", "ClientID", ",", "\"", "\"", ":", "gc", ".", "ClientEmail", ",", "\"", "\"", ":", "string", "(", "gc", ".", "PrivateKey", ")", ",", "}", ")", "\n", "}" ]

[ "buildJSONKey", "returns", "the", "content", "of", "the", "JSON", "key", "file", "for", "the", "credential", "values", "." ]

[ "func", "(", "gc", "Credentials", ")", "Values", "(", ")", "map", "[", "string", "]", "string", "{", "return", "map", "[", "string", "]", "string", "{", "OSEnvClientID", ":", "gc", ".", "ClientID", ",", "OSEnvClientEmail", ":", "gc", ".", "ClientEmail", ",", "OSEnvPrivateKey", ":", "string", "(", "gc", ".", "PrivateKey", ")", ",", "OSEnvProjectID", ":", "gc", ".", "ProjectID", ",", "}", "\n", "}" ]

[ "Values", "returns", "the", "credentials", "as", "a", "simple", "mapping", "with", "the", "corresponding", "OS", "env", "variable", "names", "as", "the", "keys", "." ]

[ "func", "(", "gc", "Credentials", ")", "Validate", "(", ")", "error", "{", "if", "gc", ".", "ClientID", "==", "\"", "\"", "{", "return", "NewMissingConfigValue", "(", "OSEnvClientID", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "gc", ".", "ClientEmail", "==", "\"", "\"", "{", "return", "NewMissingConfigValue", "(", "OSEnvClientEmail", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "mail", ".", "ParseAddress", "(", "gc", ".", "ClientEmail", ")", ";", "err", "!=", "nil", "{", "return", "NewInvalidConfigValueError", "(", "OSEnvClientEmail", ",", "gc", ".", "ClientEmail", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "gc", ".", "PrivateKey", ")", "==", "0", "{", "return", "NewMissingConfigValue", "(", "OSEnvPrivateKey", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "the", "credentialss", "for", "invalid", "values", ".", "If", "the", "values", "are", "not", "valid", "it", "returns", "errors", ".", "NotValid", "with", "the", "message", "set", "to", "the", "corresponding", "OS", "environment", "variable", "name", ".", "To", "be", "considered", "valid", "each", "of", "the", "credentials", "must", "be", "set", "to", "some", "non", "-", "empty", "value", ".", "Furthermore", "ClientEmail", "must", "be", "a", "proper", "email", "address", "." ]

[ "func", "(", "gc", "ConnectionConfig", ")", "Validate", "(", ")", "error", "{", "if", "gc", ".", "Region", "==", "\"", "\"", "{", "return", "NewMissingConfigValue", "(", "OSEnvRegion", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "gc", ".", "ProjectID", "==", "\"", "\"", "{", "return", "NewMissingConfigValue", "(", "OSEnvProjectID", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "the", "connection", "s", "fields", "for", "invalid", "values", ".", "If", "the", "values", "are", "not", "valid", "it", "returns", "a", "config", ".", "InvalidConfigValueError", "error", "with", "the", "key", "set", "to", "the", "corresponding", "OS", "environment", "variable", "name", ".", "To", "be", "considered", "valid", "each", "of", "the", "connection", "s", "must", "be", "set", "to", "some", "non", "-", "empty", "value", "." ]

[ "func", "CreateSubnetMatcher", "(", "subnetQuery", "string", ")", "SubnetMatcher", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "subnetQuery", ")", "\n", "_", ",", "ipNet", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "subnetQuery", ")", "\n", "if", "err", "==", "nil", "{", "return", "&", "cidrSubnetMatcher", "{", "ipNet", ":", "ipNet", ",", "CIDR", ":", "ipNet", ".", "String", "(", ")", ",", "}", "\n", "}", "\n", "if", "strings", ".", "HasPrefix", "(", "subnetQuery", ",", "\"", "\"", ")", "{", "return", "&", "subnetIDMatcher", "{", "subnetID", ":", "subnetQuery", ",", "}", "\n", "}", "\n", "return", "&", "subnetNameMatcher", "{", "name", ":", "subnetQuery", ",", "}", "\n", "}" ]

[ "CreateSubnetMatcher", "creates", "a", "SubnetMatcher", "that", "handles", "a", "particular", "method", "of", "comparison", "based", "on", "the", "content", "of", "the", "subnet", "query", ".", "If", "the", "query", "looks", "like", "a", "CIDR", "then", "we", "will", "match", "subnets", "with", "the", "same", "CIDR", ".", "If", "it", "follows", "the", "syntax", "of", "a", "subnet", "-", "XXXX", "then", "we", "will", "match", "the", "Subnet", "ID", ".", "Everything", "else", "is", "just", "matched", "as", "a", "Name", "." ]

[ "func", "(", "ctx", "*", "hookContext", ")", "Flush", "(", "process", "string", ",", "ctxErr", "error", ")", "(", "err", "error", ")", "{", "return", "ctx", ".", "recorder", ".", "Close", "(", ")", "\n", "}" ]

[ "Flush", "implements", "runner", ".", "Context", "." ]

[ "func", "(", "ctx", "*", "hookContext", ")", "AddMetric", "(", "key", "string", ",", "value", "string", ",", "created", "time", ".", "Time", ")", "error", "{", "return", "ctx", ".", "recorder", ".", "AddMetric", "(", "key", ",", "value", ",", "created", ",", "nil", ")", "\n", "}" ]

[ "AddMetric", "implements", "runner", ".", "Context", "." ]

[ "func", "(", "ctx", "*", "hookContext", ")", "AddMetricLabels", "(", "key", "string", ",", "value", "string", ",", "created", "time", ".", "Time", ",", "labels", "map", "[", "string", "]", "string", ")", "error", "{", "return", "ctx", ".", "recorder", ".", "AddMetric", "(", "key", ",", "value", ",", "created", ",", "labels", ")", "\n", "}" ]

[ "AddMetricLabels", "implements", "runner", ".", "Context", "." ]

[ "func", "(", "ctx", "*", "hookContext", ")", "addJujuUnitsMetric", "(", ")", "error", "{", "if", "ctx", ".", "recorder", ".", "IsDeclaredMetric", "(", "\"", "\"", ")", "{", "// TODO(fwereade): 2016-03-17 lp:1558657", "err", ":=", "ctx", ".", "recorder", ".", "AddMetric", "(", "\"", "\"", ",", "\"", "\"", ",", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "addJujuUnitsMetric", "adds", "the", "juju", "-", "units", "built", "in", "metric", "if", "it", "is", "defined", "for", "this", "context", "." ]

[ "func", "(", "ctx", "*", "hookContext", ")", "Component", "(", "name", "string", ")", "(", "jujuc", ".", "ContextComponent", ",", "error", ")", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "name", ")", "\n", "}" ]

[ "Component", "implements", "runner", ".", "Context", "." ]

[ "func", "NewProvider", "(", "config", "ProviderConfig", ")", "(", "environs", ".", "CloudEnvironProvider", ",", "error", ")", "{", "environProvider", ",", "err", ":=", "NewEnvironProvider", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "environProvider", ",", "nil", "\n", "}" ]

[ "NewProvider", "instantiates", "and", "returns", "the", "Azure", "EnvironProvider", "using", "the", "given", "configuration", "." ]

[ "func", "NewFacade", "(", "apiCaller", "base", ".", "APICaller", ",", "newWatcher", "NewWatcherFunc", ")", "*", "Facade", "{", "facadeCaller", ":=", "base", ".", "NewFacadeCaller", "(", "apiCaller", ",", "\"", "\"", ")", "\n", "return", "&", "Facade", "{", "caller", ":", "facadeCaller", ",", "newWatcher", ":", "newWatcher", ",", "}", "\n", "}" ]

[ "NewFacade", "returns", "a", "Facade", "backed", "by", "the", "supplied", "api", "caller", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "Phase", "(", "uuid", "string", ")", "(", "migration", ".", "Phase", ",", "error", ")", "{", "results", ":=", "params", ".", "PhaseResults", "{", "}", "\n", "err", ":=", "facade", ".", "call", "(", "\"", "\"", ",", "uuid", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "migration", ".", "UNKNOWN", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "count", ":=", "len", "(", "results", ".", "Results", ")", ";", "count", "!=", "1", "{", "return", "migration", ".", "UNKNOWN", ",", "countError", "(", "count", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "migration", ".", "UNKNOWN", ",", "errors", ".", "Trace", "(", "result", ".", "Error", ")", "\n", "}", "\n", "phase", ",", "ok", ":=", "migration", ".", "ParsePhase", "(", "result", ".", "Phase", ")", "\n", "if", "!", "ok", "{", "err", ":=", "errors", ".", "Errorf", "(", "\"", "\"", ",", "result", ".", "Phase", ")", "\n", "return", "migration", ".", "UNKNOWN", ",", "err", "\n", "}", "\n", "return", "phase", ",", "nil", "\n", "}" ]

[ "Phase", "returns", "the", "current", "migration", ".", "Phase", "for", "the", "supplied", "model", "UUID", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "Watch", "(", "uuid", "string", ")", "(", "watcher", ".", "NotifyWatcher", ",", "error", ")", "{", "results", ":=", "params", ".", "NotifyWatchResults", "{", "}", "\n", "err", ":=", "facade", ".", "call", "(", "\"", "\"", ",", "uuid", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "count", ":=", "len", "(", "results", ".", "Results", ")", ";", "count", "!=", "1", "{", "return", "nil", ",", "countError", "(", "count", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "result", ".", "Error", ")", "\n", "}", "\n", "apiCaller", ":=", "facade", ".", "caller", ".", "RawAPICaller", "(", ")", "\n", "watcher", ":=", "facade", ".", "newWatcher", "(", "apiCaller", ",", "result", ")", "\n", "return", "watcher", ",", "nil", "\n", "}" ]

[ "Watch", "returns", "a", "NotifyWatcher", "that", "will", "inform", "of", "potential", "changes", "to", "the", "result", "of", "Phase", "for", "the", "supplied", "model", "UUID", "." ]

[ "func", "(", "facade", "*", "Facade", ")", "call", "(", "name", ",", "uuid", "string", ",", "results", "interface", "{", "}", ")", "error", "{", "model", ":=", "names", ".", "NewModelTag", "(", "uuid", ")", ".", "String", "(", ")", "\n", "args", ":=", "params", ".", "Entities", "{", "[", "]", "params", ".", "Entity", "{", "{", "model", "}", "}", "}", "\n", "err", ":=", "facade", ".", "caller", ".", "FacadeCall", "(", "name", ",", "args", ",", "results", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "call", "converts", "the", "supplied", "model", "uuid", "into", "a", "params", ".", "Entities", "and", "invokes", "the", "facade", "caller", "." ]

[ "func", "(", "s", "*", "debugLogSocketImpl", ")", "sendError", "(", "err", "error", ")", "{", "if", "sendErr", ":=", "s", ".", "conn", ".", "SendInitialErrorV0", "(", "err", ")", ";", "sendErr", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "s", ".", "conn", ".", "Close", "(", ")", "\n", "return", "\n", "}", "\n", "}" ]

[ "sendError", "implements", "debugLogSocket", "." ]

[ "func", "NewMockMeterStatusState", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockMeterStatusState", "{", "mock", ":=", "&", "MockMeterStatusState", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockMeterStatusStateMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "newMetricsManager", "(", "client", "metricsmanager", ".", "MetricsManagerClient", ",", "notify", "chan", "string", ")", "(", "*", "worker", ".", "Runner", ",", "error", ")", "{", "// TODO(fwereade): break this out into separate manifolds (with their own facades).", "// Periodic workers automatically retry so none should return an error. If they do", "// it's ok to restart them individually.", "isFatal", ":=", "func", "(", "error", ")", "bool", "{", "return", "false", "\n", "}", "\n", "runner", ":=", "worker", ".", "NewRunner", "(", "worker", ".", "RunnerParams", "{", "IsFatal", ":", "isFatal", ",", "RestartDelay", ":", "jworker", ".", "RestartDelay", ",", "}", ")", "\n", "err", ":=", "runner", ".", "StartWorker", "(", "\"", "\"", ",", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "return", "newSender", "(", "client", ",", "notify", ")", ",", "nil", "\n", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "runner", ".", "StartWorker", "(", "\"", "\"", ",", "func", "(", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "return", "newCleanup", "(", "client", ",", "notify", ")", ",", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "runner", ",", "nil", "\n", "}" ]

[ "NewMetricsManager", "creates", "a", "runner", "that", "will", "run", "the", "metricsmanagement", "workers", "." ]

[ "func", "NewLeadershipServiceFacade", "(", "context", "facade", ".", "Context", ")", "(", "LeadershipService", ",", "error", ")", "{", "claimer", ",", "err", ":=", "context", ".", "LeadershipClaimer", "(", "context", ".", "State", "(", ")", ".", "ModelUUID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "NewLeadershipService", "(", "claimer", ",", "context", ".", "Auth", "(", ")", ")", "\n", "}" ]

[ "NewLeadershipServiceFacade", "constructs", "a", "new", "LeadershipService", "and", "presents", "a", "signature", "that", "can", "be", "used", "for", "facade", "registration", "." ]

[ "func", "NewLeadershipService", "(", "claimer", "leadership", ".", "Claimer", ",", "authorizer", "facade", ".", "Authorizer", ",", ")", "(", "LeadershipService", ",", "error", ")", "{", "if", "!", "authorizer", ".", "AuthUnitAgent", "(", ")", "&&", "!", "authorizer", ".", "AuthApplicationAgent", "(", ")", "{", "return", "nil", ",", "errors", ".", "Unauthorizedf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "leadershipService", "{", "claimer", ":", "claimer", ",", "authorizer", ":", "authorizer", ",", "}", ",", "nil", "\n", "}" ]

[ "NewLeadershipService", "constructs", "a", "new", "LeadershipService", "." ]

[ "func", "(", "m", "*", "leadershipService", ")", "ClaimLeadership", "(", "args", "params", ".", "ClaimLeadershipBulkParams", ")", "(", "params", ".", "ClaimLeadershipBulkResults", ",", "error", ")", "{", "results", ":=", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "args", ".", "Params", ")", ")", "\n", "for", "pIdx", ",", "p", ":=", "range", "args", ".", "Params", "{", "result", ":=", "&", "results", "[", "pIdx", "]", "\n", "applicationTag", ",", "unitTag", ",", "err", ":=", "parseApplicationAndUnitTags", "(", "p", ".", "ApplicationTag", ",", "p", ".", "UnitTag", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "duration", ":=", "time", ".", "Duration", "(", "p", ".", "DurationSeconds", "*", "float64", "(", "time", ".", "Second", ")", ")", "\n", "if", "duration", ">", "MaxLeaseRequest", "||", "duration", "<", "MinLeaseRequest", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "continue", "\n", "}", "\n\n", "// In the future, situations may arise wherein units will make", "// leadership claims for other units. For now, units can only", "// claim leadership for themselves, for their own service.", "authTag", ":=", "m", ".", "authorizer", ".", "GetAuthTag", "(", ")", "\n", "canClaim", ":=", "false", "\n", "switch", "authTag", ".", "(", "type", ")", "{", "case", "names", ".", "UnitTag", ":", "canClaim", "=", "m", ".", "authorizer", ".", "AuthOwner", "(", "unitTag", ")", "&&", "m", ".", "authMember", "(", "applicationTag", ")", "\n", "case", "names", ".", "ApplicationTag", ":", "canClaim", "=", "m", ".", "authorizer", ".", "AuthOwner", "(", "applicationTag", ")", "\n", "}", "\n", "if", "!", "canClaim", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "common", ".", "ErrPerm", ")", "\n", "continue", "\n", "}", "\n", "if", "err", "=", "m", ".", "claimer", ".", "ClaimLeadership", "(", "applicationTag", ".", "Id", "(", ")", ",", "unitTag", ".", "Id", "(", ")", ",", "duration", ")", ";", "err", "!=", "nil", "{", "result", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "params", ".", "ClaimLeadershipBulkResults", "{", "results", "}", ",", "nil", "\n", "}" ]

[ "ClaimLeadership", "is", "part", "of", "the", "LeadershipService", "interface", "." ]

[ "func", "(", "m", "*", "leadershipService", ")", "BlockUntilLeadershipReleased", "(", "ctx", "context", ".", "Context", ",", "applicationTag", "names", ".", "ApplicationTag", ")", "(", "params", ".", "ErrorResult", ",", "error", ")", "{", "authTag", ":=", "m", ".", "authorizer", ".", "GetAuthTag", "(", ")", "\n", "hasPerm", ":=", "false", "\n", "switch", "authTag", ".", "(", "type", ")", "{", "case", "names", ".", "UnitTag", ":", "hasPerm", "=", "m", ".", "authMember", "(", "applicationTag", ")", "\n", "case", "names", ".", "ApplicationTag", ":", "hasPerm", "=", "m", ".", "authorizer", ".", "AuthOwner", "(", "applicationTag", ")", "\n", "}", "\n\n", "if", "!", "hasPerm", "{", "return", "params", ".", "ErrorResult", "{", "Error", ":", "common", ".", "ServerError", "(", "common", ".", "ErrPerm", ")", "}", ",", "nil", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "claimer", ".", "BlockUntilLeadershipReleased", "(", "applicationTag", ".", "Id", "(", ")", ",", "ctx", ".", "Done", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "ErrorResult", "{", "Error", ":", "common", ".", "ServerError", "(", "err", ")", "}", ",", "nil", "\n", "}", "\n", "return", "params", ".", "ErrorResult", "{", "}", ",", "nil", "\n", "}" ]

[ "BlockUntilLeadershipReleased", "implements", "the", "LeadershipService", "interface", "." ]

[ "func", "parseApplicationAndUnitTags", "(", "applicationTagString", ",", "unitTagString", "string", ",", ")", "(", "names", ".", "ApplicationTag", ",", "names", ".", "UnitTag", ",", "error", ",", ")", "{", "// TODO(fwereade) 2015-02-25 bug #1425506", "// These permissions errors are not appropriate -- there's no permission or", "// security issue in play here, because our tag format is public, and the", "// error only triggers when the strings fail to match that format.", "applicationTag", ",", "err", ":=", "names", ".", "ParseApplicationTag", "(", "applicationTagString", ")", "\n", "if", "err", "!=", "nil", "{", "return", "names", ".", "ApplicationTag", "{", "}", ",", "names", ".", "UnitTag", "{", "}", ",", "common", ".", "ErrPerm", "\n", "}", "\n\n", "unitTag", ",", "err", ":=", "names", ".", "ParseUnitTag", "(", "unitTagString", ")", "\n", "if", "err", "!=", "nil", "{", "return", "names", ".", "ApplicationTag", "{", "}", ",", "names", ".", "UnitTag", "{", "}", ",", "common", ".", "ErrPerm", "\n", "}", "\n\n", "return", "applicationTag", ",", "unitTag", ",", "nil", "\n", "}" ]

[ "parseApplicationAndUnitTags", "takes", "in", "string", "representations", "of", "application", "and", "unit", "tags", "and", "returns", "their", "corresponding", "tags", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "subordinateOps", "(", ")", "(", "[", "]", "txn", ".", "Op", ",", "string", ",", "error", ")", "{", "units", ",", "closer", ":=", "ru", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "unitsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "if", "!", "ru", ".", "isPrincipal", "||", "ru", ".", "endpoint", ".", "Scope", "!=", "charm", ".", "ScopeContainer", "{", "return", "nil", ",", "\"", "\"", ",", "nil", "\n", "}", "\n", "related", ",", "err", ":=", "ru", ".", "relation", ".", "RelatedEndpoints", "(", "ru", ".", "endpoint", ".", "ApplicationName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "len", "(", "related", ")", "!=", "1", "{", "return", "nil", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "related", ")", "\n", "}", "\n", "applicationname", ",", "unitName", ":=", "related", "[", "0", "]", ".", "ApplicationName", ",", "ru", ".", "unitName", "\n", "selSubordinate", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "applicationname", "}", ",", "{", "\"", "\"", ",", "unitName", "}", "}", "\n", "var", "lDoc", "lifeDoc", "\n", "if", "err", ":=", "units", ".", "Find", "(", "selSubordinate", ")", ".", "One", "(", "&", "lDoc", ")", ";", "err", "==", "mgo", ".", "ErrNotFound", "{", "application", ",", "err", ":=", "ru", ".", "st", ".", "Application", "(", "applicationname", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "_", ",", "ops", ",", "err", ":=", "application", ".", "addUnitOps", "(", "unitName", ",", "AddUnitParams", "{", "}", ",", "nil", ")", "\n", "return", "ops", ",", "\"", "\"", ",", "err", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "else", "if", "lDoc", ".", "Life", "!=", "Alive", "{", "return", "nil", ",", "\"", "\"", ",", "ErrCannotEnterScopeYet", "\n", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "unitsC", ",", "Id", ":", "lDoc", ".", "Id", ",", "Assert", ":", "isAliveDoc", ",", "}", "}", ",", "lDoc", ".", "Id", ",", "nil", "\n", "}" ]

[ "subordinateOps", "returns", "any", "txn", "operations", "necessary", "to", "ensure", "sane", "subordinate", "state", "when", "entering", "scope", ".", "If", "a", "required", "subordinate", "unit", "exists", "and", "is", "Alive", "its", "name", "will", "be", "returned", "as", "well", ";", "if", "one", "exists", "but", "is", "not", "Alive", "ErrCannotEnterScopeYet", "is", "returned", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "LeaveScopeOperation", "(", "force", "bool", ")", "*", "LeaveScopeOperation", "{", "return", "&", "LeaveScopeOperation", "{", "ru", ":", "&", "RelationUnit", "{", "st", ":", "ru", ".", "st", ",", "relation", ":", "ru", ".", "relation", ",", "unitName", ":", "ru", ".", "unitName", ",", "isPrincipal", ":", "ru", ".", "isPrincipal", ",", "endpoint", ":", "ru", ".", "endpoint", ",", "scope", ":", "ru", ".", "scope", ",", "isLocalUnit", ":", "ru", ".", "isLocalUnit", ",", "}", ",", "ForcedOperation", ":", "ForcedOperation", "{", "Force", ":", "force", "}", ",", "}", "\n", "}" ]

[ "LeaveScopeOperation", "returns", "a", "model", "operation", "that", "will", "allow", "relation", "to", "leave", "scope", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "leaveScopeForcedOps", "(", "existingOperation", "*", "ForcedOperation", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "// It does not matter that we are say false to force here- we'll overwrite the whole ForcedOperation.", "leaveScopeOperation", ":=", "ru", ".", "LeaveScopeOperation", "(", "false", ")", "\n", "leaveScopeOperation", ".", "ForcedOperation", "=", "*", "existingOperation", "\n", "return", "leaveScopeOperation", ".", "internalLeaveScope", "(", ")", "\n", "}" ]

[ "leaveScopeForcedOps", "is", "an", "internal", "method", "used", "by", "other", "state", "objects", "when", "they", "just", "want", "to", "get", "database", "operations", "that", "are", "involved", "in", "leaving", "scop", "without", "the", "actual", "immeiate", "act", "of", "leaving", "scope", "." ]

[ "func", "(", "op", "*", "LeaveScopeOperation", ")", "internalLeaveScope", "(", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "relationScopes", ",", "closer", ":=", "op", ".", "ru", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "relationScopesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "key", ":=", "op", ".", "ru", ".", "key", "(", ")", "\n", "// The logic below is involved because we remove a dying relation", "// with the last unit that leaves a scope in it. It handles three", "// possible cases:", "//", "// 1. Relation is alive: just leave the scope.", "//", "// 2. Relation is dying, and other units remain: just leave the scope.", "//", "// 3. Relation is dying, and this is the last unit: leave the scope", "// and remove the relation.", "//", "// In each of those cases, proper assertions are done to guarantee", "// that the condition observed is still valid when the transaction is", "// applied. If an abort happens, it observes the new condition and", "// retries. In theory, a worst case will try at most all of the", "// conditions once, because units cannot join a scope once its relation", "// is dying.", "//", "// Keep in mind that in the first iteration of the loop it's possible", "// to have a Dying relation with a smaller-than-real unit count, because", "// Destroy changes the Life attribute in memory (units could join before", "// the database is actually changed).", "logger", ".", "Debugf", "(", "\"", "\"", ",", "op", ".", "Description", "(", ")", ")", "\n", "count", ",", "err", ":=", "relationScopes", ".", "FindId", "(", "key", ")", ".", "Count", "(", ")", "\n", "if", "err", "!=", "nil", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "op", ".", "Description", "(", ")", ",", "err", ")", "\n", "if", "!", "op", ".", "Force", "{", "return", "nil", ",", "err", "\n", "}", "\n", "op", ".", "AddError", "(", "err", ")", "\n", "}", "else", "if", "count", "==", "0", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "ops", ":=", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "relationScopesC", ",", "Id", ":", "key", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Remove", ":", "true", ",", "}", "}", "\n", "if", "op", ".", "ru", ".", "relation", ".", "doc", ".", "Life", "==", "Alive", "{", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "relationsC", ",", "Id", ":", "op", ".", "ru", ".", "relation", ".", "doc", ".", "DocID", ",", "Assert", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "Alive", "}", "}", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "-", "1", "}", "}", "}", "}", ",", "}", ")", "\n", "}", "else", "if", "op", ".", "ru", ".", "relation", ".", "doc", ".", "UnitCount", ">", "1", "{", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "relationsC", ",", "Id", ":", "op", ".", "ru", ".", "relation", ".", "doc", ".", "DocID", ",", "Assert", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "}", "}", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "-", "1", "}", "}", "}", "}", ",", "}", ")", "\n", "}", "else", "{", "// When 'force' is set, this call will return needed operations", "// and accumulate all operational errors encountered in the operation.", "// If the 'force' is not set, any error will be fatal and no operations will be returned.", "relOps", ",", "err", ":=", "op", ".", "ru", ".", "relation", ".", "removeOps", "(", "\"", "\"", ",", "op", ".", "ru", ".", "unitName", ",", "&", "op", ".", "ForcedOperation", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "op", ".", "Force", "{", "return", "nil", ",", "err", "\n", "}", "\n", "op", ".", "AddError", "(", "err", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "relOps", "...", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}" ]

[ "When", "force", "is", "set", "this", "call", "will", "return", "needed", "operations", "and", "will", "accumulate", "all", "operational", "errors", "encountered", "in", "the", "operation", ".", "If", "the", "force", "is", "not", "set", "any", "error", "will", "be", "fatal", "and", "no", "operations", "will", "be", "applied", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "Joined", "(", ")", "(", "bool", ",", "error", ")", "{", "return", "ru", ".", "inScope", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "true", "}", "}", "}", "}", ")", "\n", "}" ]

[ "Joined", "returns", "whether", "the", "relation", "unit", "has", "entered", "scope", "and", "neither", "left", "it", "nor", "prepared", "to", "leave", "it", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "inScope", "(", "sel", "bson", ".", "D", ")", "(", "bool", ",", "error", ")", "{", "relationScopes", ",", "closer", ":=", "ru", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "relationScopesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "sel", "=", "append", "(", "sel", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "ru", ".", "key", "(", ")", "}", "}", "...", ")", "\n", "count", ",", "err", ":=", "relationScopes", ".", "Find", "(", "sel", ")", ".", "Count", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "count", ">", "0", ",", "nil", "\n", "}" ]

[ "inScope", "returns", "whether", "a", "scope", "document", "exists", "satisfying", "the", "supplied", "selector", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "WatchScope", "(", ")", "*", "RelationScopeWatcher", "{", "role", ":=", "counterpartRole", "(", "ru", ".", "endpoint", ".", "Role", ")", "\n", "return", "watchRelationScope", "(", "ru", ".", "st", ",", "ru", ".", "scope", ",", "role", ",", "ru", ".", "unitName", ")", "\n", "}" ]

[ "WatchScope", "returns", "a", "watcher", "which", "notifies", "of", "counterpart", "units", "entering", "and", "leaving", "the", "unit", "s", "scope", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "unitKey", "(", "uname", "string", ")", "(", "string", ",", "error", ")", "{", "uparts", ":=", "strings", ".", "Split", "(", "uname", ",", "\"", "\"", ")", "\n", "sname", ":=", "uparts", "[", "0", "]", "\n", "ep", ",", "err", ":=", "ru", ".", "relation", ".", "Endpoint", "(", "sname", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "ru", ".", "_key", "(", "string", "(", "ep", ".", "Role", ")", ",", "uname", ")", ",", "nil", "\n", "}" ]

[ "unitKey", "returns", "a", "string", "based", "on", "the", "relation", "and", "the", "supplied", "unit", "name", "which", "is", "used", "as", "a", "key", "for", "that", "unit", "within", "this", "relation", "in", "the", "settings", "presence", "and", "relationScopes", "collections", "." ]

[ "func", "(", "ru", "*", "RelationUnit", ")", "key", "(", ")", "string", "{", "return", "ru", ".", "_key", "(", "string", "(", "ru", ".", "endpoint", ".", "Role", ")", ",", "ru", ".", "unitName", ")", "\n", "}" ]

[ "key", "returns", "a", "string", "based", "on", "the", "relation", "and", "the", "current", "unit", "name", "which", "is", "used", "as", "a", "key", "for", "that", "unit", "within", "this", "relation", "in", "the", "settings", "presence", "and", "relationScopes", "collections", "." ]

[ "func", "(", "paths", "Paths", ")", "ComponentDir", "(", "name", "string", ")", "string", "{", "return", "filepath", ".", "Join", "(", "paths", ".", "State", ".", "BaseDir", ",", "name", ")", "\n", "}" ]

[ "ComponentDir", "returns", "the", "filesystem", "path", "to", "the", "directory", "containing", "all", "data", "files", "for", "a", "component", "." ]

[ "func", "NewWorkerPaths", "(", "dataDir", "string", ",", "unitTag", "names", ".", "UnitTag", ",", "worker", "string", ")", "Paths", "{", "join", ":=", "filepath", ".", "Join", "\n", "baseDir", ":=", "join", "(", "dataDir", ",", "\"", "\"", ",", "unitTag", ".", "String", "(", ")", ")", "\n", "stateDir", ":=", "join", "(", "baseDir", ",", "\"", "\"", ")", "\n\n", "socket", ":=", "func", "(", "name", "string", ",", "abstract", "bool", ")", "string", "{", "if", "os", ".", "HostOS", "(", ")", "==", "os", ".", "Windows", "{", "base", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "unitTag", ")", "\n", "if", "worker", "!=", "\"", "\"", "{", "base", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "unitTag", ",", "worker", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "`\\\\.\\pipe\\%s-%s`", ",", "base", ",", "name", ")", "\n", "}", "\n", "path", ":=", "join", "(", "baseDir", ",", "name", "+", "\"", "\"", ")", "\n", "if", "worker", "!=", "\"", "\"", "{", "path", "=", "join", "(", "baseDir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "worker", ",", "name", ")", ")", "\n", "}", "\n", "if", "abstract", "{", "path", "=", "\"", "\"", "+", "path", "\n", "}", "\n", "return", "path", "\n", "}", "\n\n", "toolsDir", ":=", "tools", ".", "ToolsDir", "(", "dataDir", ",", "unitTag", ".", "String", "(", ")", ")", "\n", "return", "Paths", "{", "ToolsDir", ":", "filepath", ".", "FromSlash", "(", "toolsDir", ")", ",", "Runtime", ":", "RuntimePaths", "{", "JujuRunSocket", ":", "socket", "(", "\"", "\"", ",", "false", ")", ",", "JujucServerSocket", ":", "socket", "(", "\"", "\"", ",", "true", ")", ",", "}", ",", "State", ":", "StatePaths", "{", "BaseDir", ":", "baseDir", ",", "CharmDir", ":", "join", "(", "baseDir", ",", "\"", "\"", ")", ",", "OperationsFile", ":", "join", "(", "stateDir", ",", "\"", "\"", ")", ",", "RelationsDir", ":", "join", "(", "stateDir", ",", "\"", "\"", ")", ",", "BundlesDir", ":", "join", "(", "stateDir", ",", "\"", "\"", ")", ",", "DeployerDir", ":", "join", "(", "stateDir", ",", "\"", "\"", ")", ",", "StorageDir", ":", "join", "(", "stateDir", ",", "\"", "\"", ")", ",", "MetricsSpoolDir", ":", "join", "(", "stateDir", ",", "\"", "\"", ",", "\"", "\"", ")", ",", "}", ",", "}", "\n", "}" ]

[ "NewWorkerPaths", "returns", "the", "set", "of", "filesystem", "paths", "that", "the", "supplied", "unit", "worker", "should", "use", "given", "the", "supplied", "root", "juju", "data", "directory", "path", "and", "worker", "identifier", ".", "Distinct", "worker", "identifiers", "ensure", "that", "runtime", "paths", "of", "different", "worker", "do", "not", "interfere", "." ]

[ "func", "NewClient", "(", "caller", "base", ".", "APICaller", ",", "tag", "names", ".", "UnitTag", ")", "MeterStatusClient", "{", "return", "&", "Client", "{", "facade", ":", "base", ".", "NewFacadeCaller", "(", "caller", ",", "\"", "\"", ")", ",", "tag", ":", "tag", ",", "}", "\n", "}" ]

[ "NewClient", "creates", "a", "new", "client", "for", "accessing", "the", "MeterStatus", "API", "." ]

[ "func", "(", "c", "*", "Client", ")", "MeterStatus", "(", ")", "(", "statusCode", ",", "statusInfo", "string", ",", "rErr", "error", ")", "{", "var", "results", "params", ".", "MeterStatusResults", "\n", "args", ":=", "params", ".", "Entities", "{", "Entities", ":", "[", "]", "params", ".", "Entity", "{", "{", "Tag", ":", "c", ".", "tag", ".", "String", "(", ")", "}", "}", ",", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Trace", "(", "result", ".", "Error", ")", "\n", "}", "\n", "return", "result", ".", "Code", ",", "result", ".", "Info", ",", "nil", "\n", "}" ]

[ "MeterStatus", "is", "part", "of", "the", "MeterStatusClient", "interface", "." ]

[ "func", "(", "s", "statePoolShim", ")", "Get", "(", "modelUUID", "string", ")", "(", "PooledModelBackend", ",", "error", ")", "{", "m", ",", "err", ":=", "s", ".", "StatePool", ".", "Get", "(", "modelUUID", ")", "\n", "return", "NewPooledModelBackend", "(", "m", ")", ",", "err", "\n", "}" ]

[ "Get", "implements", "ModelPoolBackend", ".", "Get", "." ]

[ "func", "(", "s", "modelShim", ")", "Model", "(", ")", "credentialcommon", ".", "PersistentBackend", "{", "return", "credentialcommon", ".", "NewPersistentBackend", "(", "s", ".", "PooledState", ".", "State", ")", "\n", "}" ]

[ "Model", "implements", "PooledModelBackend", ".", "Model", "." ]

[ "func", "EncodeChecksum", "(", "checksum", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "DigestSHA256", ",", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "[", "]", "byte", "(", "checksum", ")", ")", ")", "\n", "}" ]

[ "EncodeChecksum", "base64", "encodes", "a", "sha256", "checksum", "according", "to", "RFC", "4648", "and", "returns", "a", "value", "that", "can", "be", "added", "to", "the", "Digest", "http", "header", "." ]

[ "func", "NewFacadeCaller", "(", "caller", "APICaller", ",", "facadeName", "string", ")", "FacadeCaller", "{", "return", "NewFacadeCallerForVersion", "(", "caller", ",", "facadeName", ",", "caller", ".", "BestFacadeVersion", "(", "facadeName", ")", ")", "\n", "}" ]

[ "NewFacadeCaller", "wraps", "an", "APICaller", "for", "a", "given", "facade", "name", "and", "the", "best", "available", "version", "." ]

[ "func", "NewFacadeCallerForVersion", "(", "caller", "APICaller", ",", "facadeName", "string", ",", "version", "int", ")", "FacadeCaller", "{", "return", "facadeCaller", "{", "facadeName", ":", "facadeName", ",", "bestVersion", ":", "version", ",", "caller", ":", "caller", ",", "}", "\n", "}" ]

[ "NewFacadeCallerForVersion", "wraps", "an", "APICaller", "for", "a", "given", "facade", "name", "and", "version", "." ]