Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.3k

[ "func", "(", "ns", "nsRefcounts_", ")", "RemoveOp", "(", "coll", "mongo", ".", "Collection", ",", "key", "string", ",", "value", "int", ")", "(", "txn", ".", "Op", ",", "error", ")", "{", "refcount", ",", "err", ":=", "ns", ".", "read", "(", "coll", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "txn", ".", "Op", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "refcount", "!=", "value", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "coll", ".", "Name", "(", ")", ",", "key", ",", "refcount", ",", "value", ")", "\n", "return", "txn", ".", "Op", "{", "}", ",", "errRefcountChanged", "\n", "}", "\n", "return", "ns", ".", "JustRemoveOp", "(", "coll", ".", "Name", "(", ")", ",", "key", ",", "value", ")", ",", "nil", "\n", "}" ]

[ "RemoveOp", "returns", "a", "txn", ".", "Op", "that", "removes", "a", "refcount", "doc", "so", "long", "as", "its", "refcount", "is", "the", "supplied", "value", "or", "an", "error", "." ]

[ "func", "(", "ns", "nsRefcounts_", ")", "CurrentOp", "(", "coll", "mongo", ".", "Collection", ",", "key", "string", ")", "(", "txn", ".", "Op", ",", "int", ",", "error", ")", "{", "refcount", ",", "err", ":=", "ns", ".", "read", "(", "coll", ",", "key", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "txn", ".", "Op", "{", "C", ":", "coll", ".", "Name", "(", ")", ",", "Id", ":", "key", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "}", ",", "0", ",", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "txn", ".", "Op", "{", "}", ",", "-", "1", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "txn", ".", "Op", "{", "C", ":", "coll", ".", "Name", "(", ")", ",", "Id", ":", "key", ",", "Assert", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "refcount", "}", "}", ",", "}", ",", "refcount", ",", "nil", "\n", "}" ]

[ "CurrentOp", "returns", "the", "current", "reference", "count", "value", "and", "a", "txn", ".", "Op", "that", "asserts", "that", "the", "refcount", "has", "that", "value", "or", "an", "error", ".", "If", "the", "refcount", "doc", "does", "not", "exist", "then", "the", "op", "will", "assert", "that", "the", "document", "does", "not", "exist", "instead", "and", "no", "error", "is", "returned", "." ]

[ "func", "(", "ns", "nsRefcounts_", ")", "JustRemoveOp", "(", "collName", ",", "key", "string", ",", "count", "int", ")", "txn", ".", "Op", "{", "op", ":=", "txn", ".", "Op", "{", "C", ":", "collName", ",", "Id", ":", "key", ",", "Remove", ":", "true", ",", "}", "\n", "if", "count", ">=", "0", "{", "op", ".", "Assert", "=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "count", "}", "}", "\n", "}", "\n", "return", "op", "\n", "}" ]

[ "JustRemoveOp", "returns", "a", "txn", ".", "Op", "that", "deletes", "a", "refcount", "doc", "so", "long", "as", "the", "refcount", "matches", "count", ".", "You", "should", "avoid", "using", "this", "method", "in", "most", "cases", "." ]

[ "func", "(", "nsRefcounts_", ")", "exists", "(", "coll", "mongo", ".", "Collection", ",", "key", "string", ")", "(", "bool", ",", "error", ")", "{", "count", ",", "err", ":=", "coll", ".", "FindId", "(", "key", ")", ".", "Count", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "count", "!=", "0", ",", "nil", "\n", "}" ]

[ "exists", "returns", "whether", "the", "identified", "refcount", "doc", "exists", "." ]

[ "func", "(", "nsRefcounts_", ")", "read", "(", "coll", "mongo", ".", "Collection", ",", "key", "string", ")", "(", "int", ",", "error", ")", "{", "var", "doc", "refcountDoc", "\n", "if", "err", ":=", "coll", ".", "FindId", "(", "key", ")", ".", "One", "(", "&", "doc", ")", ";", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "0", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "0", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "doc", ".", "RefCount", ",", "nil", "\n", "}" ]

[ "read", "returns", "the", "value", "stored", "in", "the", "identified", "refcount", "doc", "." ]

[ "func", "newConfig", "(", "cfg", "*", "config", ".", "Config", ")", "*", "environConfig", "{", "return", "&", "environConfig", "{", "Config", ":", "cfg", ",", "attrs", ":", "cfg", ".", "UnknownAttrs", "(", ")", ",", "}", "\n", "}" ]

[ "newConfig", "builds", "a", "new", "environConfig", "from", "the", "provided", "Config", "and", "returns", "it", "." ]

[ "func", "newValidConfig", "(", "cfg", "*", "config", ".", "Config", ")", "(", "*", "environConfig", ",", "error", ")", "{", "// Ensure that the provided config is valid.", "if", "err", ":=", "config", ".", "Validate", "(", "cfg", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Build the config.", "ecfg", ":=", "newConfig", "(", "cfg", ")", "\n\n", "// Do final (more complex, provider-specific) validation.", "if", "err", ":=", "ecfg", ".", "validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "ecfg", ",", "nil", "\n", "}" ]

[ "newValidConfig", "builds", "a", "new", "environConfig", "from", "the", "provided", "Config", "and", "returns", "it", ".", "This", "includes", "applying", "the", "provided", "defaults", "values", "if", "any", ".", "The", "resulting", "config", "values", "are", "validated", "." ]

[ "func", "(", "c", "*", "environConfig", ")", "validate", "(", ")", "error", "{", "_", ",", "err", ":=", "c", ".", "ValidateUnknownAttrs", "(", "configFields", ",", "configDefaults", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// There are currently no known extra fields for LXD", "return", "nil", "\n", "}" ]

[ "validate", "validates", "LXD", "-", "specific", "configuration", "." ]

[ "func", "NewHostPreparer", "(", "params", "HostPreparerParams", ")", "*", "HostPreparer", "{", "return", "&", "HostPreparer", "{", "api", ":", "params", ".", "API", ",", "observeNetworkFunc", ":", "params", ".", "ObserveNetworkFunc", ",", "acquireLockFunc", ":", "params", ".", "AcquireLockFunc", ",", "createBridger", ":", "params", ".", "CreateBridger", ",", "abortChan", ":", "params", ".", "AbortChan", ",", "machineTag", ":", "params", ".", "MachineTag", ",", "logger", ":", "params", ".", "Logger", ",", "}", "\n", "}" ]

[ "NewHostPreparer", "creates", "a", "HostPreparer", "using", "the", "supplied", "parameters" ]

[ "func", "(", "hp", "*", "HostPreparer", ")", "Prepare", "(", "containerTag", "names", ".", "MachineTag", ")", "error", "{", "devicesToBridge", ",", "reconfigureDelay", ",", "err", ":=", "hp", ".", "api", ".", "HostChangesForContainer", "(", "containerTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "devicesToBridge", ")", "==", "0", "{", "hp", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "containerTag", ")", "\n", "return", "nil", "\n", "}", "\n\n", "bridger", ",", "err", ":=", "hp", ".", "createBridger", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "hp", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "devicesToBridge", ",", "hp", ".", "machineTag", ".", "String", "(", ")", ",", "containerTag", ".", "String", "(", ")", ",", "reconfigureDelay", ")", "\n", "releaser", ",", "err", ":=", "hp", ".", "acquireLockFunc", "(", "\"", "\"", ",", "hp", ".", "abortChan", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "releaser", "(", ")", "\n", "// TODO(jam): 2017-02-15 bridger.Bridge should probably also take AbortChan", "// if it is going to have reconfigureDelay", "err", "=", "bridger", ".", "Bridge", "(", "devicesToBridge", ",", "reconfigureDelay", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// We just changed the hosts' network setup so discover new", "// interfaces/devices and propagate to state.", "observedConfig", ",", "err", ":=", "hp", ".", "observeNetworkFunc", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "observedConfig", ")", ">", "0", "{", "hp", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "hp", ".", "machineTag", ".", "String", "(", ")", ",", "observedConfig", ")", "\n", "err", ":=", "hp", ".", "api", ".", "SetHostMachineNetworkConfig", "(", "hp", ".", "machineTag", ",", "observedConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Prepare", "applies", "changes", "to", "the", "host", "machine", "that", "are", "necessary", "to", "create", "the", "requested", "container", "." ]

[ "func", "create", "(", "args", "*", "createArgs", ")", "(", "_", "*", "createResult", ",", "err", "error", ")", "{", "// Prepare the backup builder.", "builder", ",", "err", ":=", "newBuilder", "(", "args", ".", "backupDir", ",", "args", ".", "filesToBackUp", ",", "args", ".", "db", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "cerr", ":=", "builder", ".", "cleanUp", "(", "args", ".", "noDownload", ")", ";", "cerr", "!=", "nil", "{", "cerr", ".", "Log", "(", "logger", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "cerr", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "// Inject the metadata file.", "if", "args", ".", "metadataReader", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "builder", ".", "injectMetadataFile", "(", "args", ".", "metadataReader", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Build the backup.", "if", "err", ":=", "builder", ".", "buildAll", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Get the result.", "result", ",", "err", ":=", "builder", ".", "result", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Return the result. Note that the entire build workspace will be", "// deleted at the end of this function. This includes the backup", "// archive file we built. However, the handle to that file in the", "// result will still be open and readable.", "// If we ever support state machines on Windows, this will need to", "// change (you can't delete open files on Windows).", "return", "result", ",", "nil", "\n", "}" ]

[ "create", "builds", "a", "new", "backup", "archive", "file", "and", "returns", "it", ".", "It", "also", "updates", "the", "metadata", "with", "the", "file", "info", "." ]

[ "func", "ControllerOnlyAttribute", "(", "attr", "string", ")", "bool", "{", "for", "_", ",", "a", ":=", "range", "ControllerOnlyConfigAttributes", "{", "if", "attr", "==", "a", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "ControllerOnlyAttribute", "returns", "true", "if", "the", "specified", "attribute", "name", "is", "only", "relevant", "for", "a", "controller", "." ]

[ "func", "(", "c", "Config", ")", "mustInt", "(", "name", "string", ")", "int", "{", "// Values obtained over the api are encoded as float64.", "if", "value", ",", "ok", ":=", "c", "[", "name", "]", ".", "(", "float64", ")", ";", "ok", "{", "return", "int", "(", "value", ")", "\n", "}", "\n", "value", ",", "_", ":=", "c", "[", "name", "]", ".", "(", "int", ")", "\n", "if", "value", "==", "0", "{", "panic", "(", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "}", "\n", "return", "value", "\n", "}" ]

[ "mustInt", "returns", "the", "named", "attribute", "as", "an", "integer", "panicking", "if", "it", "is", "not", "found", "or", "is", "zero", ".", "Zero", "values", "should", "have", "been", "diagnosed", "at", "Validate", "time", "." ]

[ "func", "(", "c", "Config", ")", "APIPortOpenDelay", "(", ")", "time", ".", "Duration", "{", "v", ":=", "c", ".", "asString", "(", "APIPortOpenDelay", ")", "\n", "// We know that v must be a parseable time.Duration for the config", "// to be valid.", "d", ",", "_", ":=", "time", ".", "ParseDuration", "(", "v", ")", "\n", "return", "d", "\n", "}" ]

[ "APIPortOpenDelay", "returns", "the", "duration", "to", "wait", "before", "opening", "the", "APIPort", "once", "the", "controller", "has", "started", "up", ".", "Only", "used", "when", "the", "ControllerAPIPort", "is", "non", "-", "zero", "." ]

[ "func", "(", "c", "Config", ")", "ControllerAPIPort", "(", ")", "int", "{", "if", "value", ",", "ok", ":=", "c", "[", "ControllerAPIPort", "]", ".", "(", "float64", ")", ";", "ok", "{", "return", "int", "(", "value", ")", "\n", "}", "\n", "// If the value isn't an int, this conversion will fail and value", "// will be 0, which is what we want here.", "value", ",", "_", ":=", "c", "[", "ControllerAPIPort", "]", ".", "(", "int", ")", "\n", "return", "value", "\n", "}" ]

[ "ControllerAPIPort", "returns", "the", "optional", "API", "port", "to", "be", "used", "for", "the", "controllers", "to", "talk", "to", "each", "other", ".", "A", "zero", "value", "means", "that", "it", "is", "not", "set", "." ]

[ "func", "(", "c", "Config", ")", "AuditingEnabled", "(", ")", "bool", "{", "if", "v", ",", "ok", ":=", "c", "[", "AuditingEnabled", "]", ";", "ok", "{", "return", "v", ".", "(", "bool", ")", "\n", "}", "\n", "return", "DefaultAuditingEnabled", "\n", "}" ]

[ "AuditingEnabled", "returns", "whether", "or", "not", "auditing", "has", "been", "enabled", "for", "the", "environment", ".", "The", "default", "is", "false", "." ]

[ "func", "(", "c", "Config", ")", "AuditLogCaptureArgs", "(", ")", "bool", "{", "if", "v", ",", "ok", ":=", "c", "[", "AuditLogCaptureArgs", "]", ";", "ok", "{", "return", "v", ".", "(", "bool", ")", "\n", "}", "\n", "return", "DefaultAuditLogCaptureArgs", "\n", "}" ]

[ "AuditLogCaptureArgs", "returns", "whether", "audit", "logging", "should", "capture", "the", "arguments", "to", "API", "methods", ".", "The", "default", "is", "false", "." ]

[ "func", "(", "c", "Config", ")", "AuditLogMaxSizeMB", "(", ")", "int", "{", "// Value has already been validated.", "value", ",", "_", ":=", "utils", ".", "ParseSize", "(", "c", ".", "asString", "(", "AuditLogMaxSize", ")", ")", "\n", "return", "int", "(", "value", ")", "\n", "}" ]

[ "AuditLogMaxSizeMB", "returns", "the", "maximum", "size", "for", "an", "audit", "log", "file", "in", "MB", "." ]

[ "func", "(", "c", "Config", ")", "AuditLogExcludeMethods", "(", ")", "set", ".", "Strings", "{", "if", "value", ",", "ok", ":=", "c", "[", "AuditLogExcludeMethods", "]", ";", "ok", "{", "value", ":=", "value", ".", "(", "[", "]", "interface", "{", "}", ")", "\n", "items", ":=", "set", ".", "NewStrings", "(", ")", "\n", "for", "_", ",", "item", ":=", "range", "value", "{", "items", ".", "Add", "(", "item", ".", "(", "string", ")", ")", "\n", "}", "\n", "return", "items", "\n", "}", "\n", "return", "set", ".", "NewStrings", "(", "DefaultAuditLogExcludeMethods", "...", ")", "\n", "}" ]

[ "AuditLogExcludeMethods", "returns", "the", "set", "of", "method", "names", "that", "are", "considered", "uninteresting", "for", "audit", "logging", ".", "Conversations", "containing", "only", "these", "will", "be", "excluded", "from", "the", "audit", "log", "." ]

[ "func", "(", "c", "Config", ")", "Features", "(", ")", "set", ".", "Strings", "{", "features", ":=", "set", ".", "NewStrings", "(", ")", "\n", "if", "value", ",", "ok", ":=", "c", "[", "Features", "]", ";", "ok", "{", "value", ":=", "value", ".", "(", "[", "]", "interface", "{", "}", ")", "\n", "for", "_", ",", "item", ":=", "range", "value", "{", "features", ".", "Add", "(", "item", ".", "(", "string", ")", ")", "\n", "}", "\n", "}", "\n", "return", "features", "\n", "}" ]

[ "Features", "returns", "the", "controller", "config", "set", "features", "flags", "." ]

[ "func", "(", "c", "Config", ")", "CharmStoreURL", "(", ")", "string", "{", "url", ":=", "c", ".", "asString", "(", "CharmStoreURL", ")", "\n", "if", "url", "==", "\"", "\"", "{", "return", "csclient", ".", "ServerURL", "\n", "}", "\n", "return", "url", "\n", "}" ]

[ "CharmStoreURL", "returns", "the", "URL", "to", "use", "for", "charmstore", "api", "calls", "." ]

[ "func", "(", "c", "Config", ")", "IdentityPublicKey", "(", ")", "*", "bakery", ".", "PublicKey", "{", "key", ":=", "c", ".", "asString", "(", "IdentityPublicKey", ")", "\n", "if", "key", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "var", "pubKey", "bakery", ".", "PublicKey", "\n", "err", ":=", "pubKey", ".", "UnmarshalText", "(", "[", "]", "byte", "(", "key", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// We check if the key string can be unmarshalled into a PublicKey in the", "// Validate function, so we really do not expect this to fail.", "panic", "(", "err", ")", "\n", "}", "\n", "return", "&", "pubKey", "\n", "}" ]

[ "IdentityPublicKey", "returns", "the", "public", "key", "of", "the", "identity", "manager", "." ]

[ "func", "(", "c", "Config", ")", "MongoMemoryProfile", "(", ")", "string", "{", "if", "profile", ",", "ok", ":=", "c", "[", "MongoMemoryProfile", "]", ";", "ok", "{", "return", "profile", ".", "(", "string", ")", "\n", "}", "\n", "return", "DefaultMongoMemoryProfile", "\n", "}" ]

[ "MongoMemoryProfile", "returns", "the", "selected", "profile", "or", "low", "." ]

[ "func", "(", "c", "Config", ")", "NUMACtlPreference", "(", ")", "bool", "{", "if", "numa", ",", "ok", ":=", "c", "[", "SetNUMAControlPolicyKey", "]", ";", "ok", "{", "return", "numa", ".", "(", "bool", ")", "\n", "}", "\n", "return", "DefaultNUMAControlPolicy", "\n", "}" ]

[ "NUMACtlPreference", "returns", "if", "numactl", "is", "preferred", "." ]

[ "func", "(", "c", "Config", ")", "AllowModelAccess", "(", ")", "bool", "{", "value", ",", "_", ":=", "c", "[", "AllowModelAccessKey", "]", ".", "(", "bool", ")", "\n", "return", "value", "\n", "}" ]

[ "AllowModelAccess", "reports", "whether", "users", "are", "allowed", "to", "access", "models", "they", "have", "been", "granted", "permission", "for", "even", "when", "they", "can", "t", "access", "the", "controller", "." ]

[ "func", "(", "c", "Config", ")", "MaxLogSizeMB", "(", ")", "int", "{", "// Value has already been validated.", "val", ",", "_", ":=", "utils", ".", "ParseSize", "(", "c", ".", "mustString", "(", "MaxLogsSize", ")", ")", "\n", "return", "int", "(", "val", ")", "\n", "}" ]

[ "MaxLogSizeMB", "is", "the", "maximum", "size", "in", "MiB", "which", "the", "log", "collection", "can", "grow", "to", "before", "being", "pruned", "." ]

[ "func", "(", "c", "Config", ")", "MaxTxnLogSizeMB", "(", ")", "int", "{", "// Value has already been validated.", "val", ",", "_", ":=", "utils", ".", "ParseSize", "(", "c", ".", "mustString", "(", "MaxTxnLogSize", ")", ")", "\n", "return", "int", "(", "val", ")", "\n", "}" ]

[ "MaxTxnLogSizeMB", "is", "the", "maximum", "size", "in", "MiB", "of", "the", "txn", "log", "collection", "." ]

[ "func", "(", "c", "Config", ")", "PruneTxnSleepTime", "(", ")", "time", ".", "Duration", "{", "asInterface", ",", "ok", ":=", "c", "[", "PruneTxnSleepTime", "]", "\n", "if", "!", "ok", "{", "asInterface", "=", "DefaultPruneTxnSleepTime", "\n", "}", "\n", "asStr", ",", "ok", ":=", "asInterface", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "asStr", "=", "DefaultPruneTxnSleepTime", "\n", "}", "\n", "val", ",", "_", ":=", "time", ".", "ParseDuration", "(", "asStr", ")", "\n", "return", "val", "\n", "}" ]

[ "PruneTxnSleepTime", "is", "the", "amount", "of", "time", "to", "sleep", "between", "batches", "." ]

[ "func", "(", "c", "Config", ")", "MeteringURL", "(", ")", "string", "{", "url", ":=", "c", ".", "asString", "(", "MeteringURL", ")", "\n", "if", "url", "==", "\"", "\"", "{", "return", "romulus", ".", "DefaultAPIRoot", "\n", "}", "\n", "return", "url", "\n", "}" ]

[ "MeteringURL", "returns", "the", "URL", "to", "use", "for", "metering", "api", "calls", "." ]

[ "func", "GenerateControllerCertAndKey", "(", "caCert", ",", "caKey", "string", ",", "hostAddresses", "[", "]", "string", ")", "(", "string", ",", "string", ",", "error", ")", "{", "return", "cert", ".", "NewDefaultServer", "(", "caCert", ",", "caKey", ",", "hostAddresses", ")", "\n", "}" ]

[ "GenerateControllerCertAndKey", "makes", "sure", "that", "the", "config", "has", "a", "CACert", "and", "CAPrivateKey", "generates", "and", "returns", "new", "certificate", "and", "key", "." ]

[ "func", "stateStepsFor234", "(", ")", "[", "]", "Step", "{", "return", "[", "]", "Step", "{", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "DeleteCloudImageMetadata", "(", ")", "\n", "}", ",", "}", ",", "}", "\n", "}" ]

[ "stateStepsFor234", "returns", "upgrade", "steps", "for", "Juju", "2", ".", "3", ".", "4", "that", "manipulate", "state", "directly", "." ]

[ "func", "NewMockDiffCommandAPI", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockDiffCommandAPI", "{", "mock", ":=", "&", "MockDiffCommandAPI", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockDiffCommandAPIMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockDiffCommandAPI", ")", "BranchInfo", "(", "arg0", "string", ",", "arg1", "bool", ",", "arg2", "func", "(", "time", ".", "Time", ")", "string", ")", "(", "map", "[", "string", "]", "model", ".", "Generation", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ",", "arg2", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "map", "[", "string", "]", "model", ".", "Generation", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "BranchInfo", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockDiffCommandAPIMockRecorder", ")", "BranchInfo", "(", "arg0", ",", "arg1", ",", "arg2", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockDiffCommandAPI", ")", "(", "nil", ")", ".", "BranchInfo", ")", ",", "arg0", ",", "arg1", ",", "arg2", ")", "\n", "}" ]

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

[ "func", "(", "a", "*", "API", ")", "List", "(", "args", "params", ".", "CharmsList", ")", "(", "params", ".", "CharmsListResult", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "params", ".", "CharmsListResult", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "charms", ",", "err", ":=", "a", ".", "backend", ".", "AllCharms", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "params", ".", "CharmsListResult", "{", "}", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "names", ":=", "set", ".", "NewStrings", "(", "args", ".", "Names", "...", ")", "\n", "checkName", ":=", "!", "names", ".", "IsEmpty", "(", ")", "\n", "charmURLs", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "aCharm", ":=", "range", "charms", "{", "charmURL", ":=", "aCharm", ".", "URL", "(", ")", "\n", "if", "checkName", "{", "if", "!", "names", ".", "Contains", "(", "charmURL", ".", "Name", ")", "{", "continue", "\n", "}", "\n", "}", "\n", "charmURLs", "=", "append", "(", "charmURLs", ",", "charmURL", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "params", ".", "CharmsListResult", "{", "CharmURLs", ":", "charmURLs", "}", ",", "nil", "\n", "}" ]

[ "List", "returns", "a", "list", "of", "charm", "URLs", "currently", "in", "the", "state", ".", "If", "supplied", "parameter", "contains", "any", "names", "the", "result", "will", "be", "filtered", "to", "return", "only", "the", "charms", "with", "supplied", "names", "." ]

[ "func", "FallbackInterfaceInfo", "(", ")", "[", "]", "network", ".", "InterfaceInfo", "{", "return", "[", "]", "network", ".", "InterfaceInfo", "{", "{", "InterfaceName", ":", "\"", "\"", ",", "InterfaceType", ":", "network", ".", "EthernetInterface", ",", "ConfigType", ":", "network", ".", "ConfigDHCP", ",", "}", "}", "\n", "}" ]

[ "FallbackInterfaceInfo", "returns", "a", "single", "eth0", "interface", "configured", "with", "DHCP", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "SetAttr", "(", "name", "string", ",", "value", "interface", "{", "}", ")", "{", "cfg", ".", "attrs", "[", "name", "]", "=", "value", "\n", "}" ]

[ "SetAttr", "is", "defined", "on", "the", "CloudConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddUser", "(", "user", "*", "User", ")", "{", "users", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "newUser", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "user", ".", "Name", ",", "\"", "\"", ":", "true", ",", "}", "\n", "if", "user", ".", "Groups", "!=", "nil", "{", "newUser", "[", "\"", "\"", "]", "=", "user", ".", "Groups", "\n", "}", "\n", "if", "user", ".", "Shell", "!=", "\"", "\"", "{", "newUser", "[", "\"", "\"", "]", "=", "user", ".", "Shell", "\n", "}", "\n", "if", "user", ".", "SSHAuthorizedKeys", "!=", "\"", "\"", "{", "newUser", "[", "\"", "\"", "]", "=", "annotateKeys", "(", "user", ".", "SSHAuthorizedKeys", ")", "\n", "}", "\n", "if", "user", ".", "Sudo", "!=", "nil", "{", "newUser", "[", "\"", "\"", "]", "=", "user", ".", "Sudo", "\n", "}", "\n", "cfg", ".", "SetAttr", "(", "\"", "\"", ",", "append", "(", "users", ",", "newUser", ")", ")", "\n", "}" ]

[ "AddUser", "is", "defined", "on", "the", "UsersConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "SystemUpdate", "(", ")", "bool", "{", "update", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "bool", ")", "\n", "return", "update", "\n", "}" ]

[ "SystemUpdate", "is", "defined", "on", "the", "SystemUpdateConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "SystemUpgrade", "(", ")", "bool", "{", "upgrade", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "bool", ")", "\n", "return", "upgrade", "\n", "}" ]

[ "SystemUpgrade", "is", "defined", "on", "the", "SystemUpgradeConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddPackage", "(", "pack", "string", ")", "{", "cfg", ".", "attrs", "[", "\"", "\"", "]", "=", "append", "(", "cfg", ".", "Packages", "(", ")", ",", "pack", ")", "\n", "}" ]

[ "AddPackage", "is", "defined", "on", "the", "PackagingConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "RemovePackage", "(", "pack", "string", ")", "{", "cfg", ".", "attrs", "[", "\"", "\"", "]", "=", "removeStringFromSlice", "(", "cfg", ".", "Packages", "(", ")", ",", "pack", ")", "\n", "}" ]

[ "RemovePackage", "is", "defined", "on", "the", "PackagingConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "Packages", "(", ")", "[", "]", "string", "{", "packs", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "[", "]", "string", ")", "\n", "return", "packs", "\n", "}" ]

[ "Packages", "is", "defined", "on", "the", "PackagingConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddRunCmd", "(", "args", "...", "string", ")", "{", "cfg", ".", "attrs", "[", "\"", "\"", "]", "=", "append", "(", "cfg", ".", "RunCmds", "(", ")", ",", "strings", ".", "Join", "(", "args", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "AddRunCmd", "is", "defined", "on", "the", "RunCmdsConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddScripts", "(", "script", "...", "string", ")", "{", "for", "_", ",", "line", ":=", "range", "script", "{", "cfg", ".", "AddRunCmd", "(", "line", ")", "\n", "}", "\n", "}" ]

[ "AddScripts", "is", "defined", "on", "the", "RunCmdsConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "RemoveRunCmd", "(", "cmd", "string", ")", "{", "cfg", ".", "attrs", "[", "\"", "\"", "]", "=", "removeStringFromSlice", "(", "cfg", ".", "RunCmds", "(", ")", ",", "cmd", ")", "\n", "}" ]

[ "RemoveRunCmd", "is", "defined", "on", "the", "RunCmdsConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "RunCmds", "(", ")", "[", "]", "string", "{", "cmds", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "[", "]", "string", ")", "\n", "return", "cmds", "\n", "}" ]

[ "RunCmds", "is", "defined", "on", "the", "RunCmdsConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddBootCmd", "(", "args", "...", "string", ")", "{", "cfg", ".", "attrs", "[", "\"", "\"", "]", "=", "append", "(", "cfg", ".", "BootCmds", "(", ")", ",", "strings", ".", "Join", "(", "args", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "AddBootCmd", "is", "defined", "on", "the", "BootCmdsConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "RemoveBootCmd", "(", "cmd", "string", ")", "{", "cfg", ".", "attrs", "[", "\"", "\"", "]", "=", "removeStringFromSlice", "(", "cfg", ".", "BootCmds", "(", ")", ",", "cmd", ")", "\n", "}" ]

[ "RemoveBootCmd", "is", "defined", "on", "the", "BootCmdsConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "BootCmds", "(", ")", "[", "]", "string", "{", "cmds", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "[", "]", "string", ")", "\n", "return", "cmds", "\n", "}" ]

[ "BootCmds", "is", "defined", "on", "the", "BootCmdsConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "DisableEC2Metadata", "(", ")", "bool", "{", "disEC2", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "bool", ")", "\n", "return", "disEC2", "\n", "}" ]

[ "DisableEC2Metadata", "is", "defined", "on", "the", "EC2MetadataConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "FinalMessage", "(", ")", "string", "{", "message", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "string", ")", "\n", "return", "message", "\n", "}" ]

[ "FinalMessage", "is", "defined", "on", "the", "FinalMessageConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "Locale", "(", ")", "string", "{", "locale", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "string", ")", "\n", "return", "locale", "\n", "}" ]

[ "Locale", "is", "defined", "on", "the", "LocaleConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "SetOutput", "(", "kind", "OutputKind", ",", "stdout", ",", "stderr", "string", ")", "{", "out", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "out", "==", "nil", "{", "out", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n\n", "if", "stderr", "==", "\"", "\"", "{", "out", "[", "string", "(", "kind", ")", "]", "=", "stdout", "\n", "}", "else", "{", "out", "[", "string", "(", "kind", ")", "]", "=", "[", "]", "string", "{", "stdout", ",", "stderr", "}", "\n", "}", "\n\n", "cfg", ".", "SetAttr", "(", "\"", "\"", ",", "out", ")", "\n", "}" ]

[ "SetOutput", "is", "defined", "on", "the", "OutputConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "Output", "(", "kind", "OutputKind", ")", "(", "stdout", ",", "stderr", "string", ")", "{", "if", "out", ",", "ok", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ";", "ok", "{", "switch", "out", ":=", "out", "[", "string", "(", "kind", ")", "]", ".", "(", "type", ")", "{", "case", "string", ":", "stdout", "=", "out", "\n", "case", "[", "]", "string", ":", "stdout", ",", "stderr", "=", "out", "[", "0", "]", ",", "out", "[", "1", "]", "\n", "}", "\n", "}", "\n\n", "return", "stdout", ",", "stderr", "\n", "}" ]

[ "Output", "is", "defined", "on", "the", "OutputConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "SetSSHAuthorizedKeys", "(", "rawKeys", "string", ")", "{", "keys", ":=", "annotateKeys", "(", "rawKeys", ")", "\n", "if", "len", "(", "keys", ")", "!=", "0", "{", "cfg", ".", "SetAttr", "(", "\"", "\"", ",", "keys", ")", "\n", "}", "else", "{", "cfg", ".", "UnsetAttr", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "SetSSHAuthorizedKeys", "is", "defined", "on", "the", "SSHAuthorizedKeysConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "SetSSHKeys", "(", "keys", "SSHKeys", ")", "{", "if", "keys", ".", "RSA", "!=", "nil", "{", "cfg", ".", "SetAttr", "(", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "string", "(", "RSAPrivate", ")", ":", "keys", ".", "RSA", ".", "Private", ",", "string", "(", "RSAPublic", ")", ":", "keys", ".", "RSA", ".", "Public", ",", "}", ")", "\n", "}", "else", "{", "cfg", ".", "UnsetAttr", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "SetSSHKeys", "is", "defined", "on", "the", "SSHKeysConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "DisableRoot", "(", ")", "bool", "{", "disable", ",", "_", ":=", "cfg", ".", "attrs", "[", "\"", "\"", "]", ".", "(", "bool", ")", "\n", "return", "disable", "\n", "}" ]

[ "DisableRoot", "is", "defined", "on", "the", "RootUserConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddRunTextFile", "(", "filename", ",", "contents", "string", ",", "perm", "uint", ")", "{", "cfg", ".", "AddScripts", "(", "addFileCmds", "(", "filename", ",", "[", "]", "byte", "(", "contents", ")", ",", "perm", ",", "false", ")", "...", ")", "\n", "}" ]

[ "AddRunTextFile", "is", "defined", "on", "the", "WrittenFilesConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddBootTextFile", "(", "filename", ",", "contents", "string", ",", "perm", "uint", ")", "{", "for", "_", ",", "cmd", ":=", "range", "addFileCmds", "(", "filename", ",", "[", "]", "byte", "(", "contents", ")", ",", "perm", ",", "false", ")", "{", "cfg", ".", "AddBootCmd", "(", "cmd", ")", "\n", "}", "\n", "}" ]

[ "AddBootTextFile", "is", "defined", "on", "the", "WrittenFilesConfig", "interface", "." ]

[ "func", "(", "cfg", "*", "cloudConfig", ")", "AddRunBinaryFile", "(", "filename", "string", ",", "data", "[", "]", "byte", ",", "mode", "uint", ")", "{", "cfg", ".", "AddScripts", "(", "addFileCmds", "(", "filename", ",", "data", ",", "mode", ",", "true", ")", "...", ")", "\n", "}" ]

[ "AddRunBinaryFile", "is", "defined", "on", "the", "WrittenFilesConfig", "interface", "." ]

[ "func", "ensureDir", "(", "d", "dirFuncs", ",", "path", "string", ")", "error", "{", "// If path already exists, we check that it is empty.", "// It is up to the storage provisioner to ensure that any", "// shared storage constraints and attachments with the same", "// path are validated etc. So the check here is more a sanity check.", "fi", ",", "err", ":=", "d", ".", "lstat", "(", "path", ")", "\n", "if", "err", "==", "nil", "{", "if", "!", "fi", ".", "IsDir", "(", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "d", ".", "mkDirAll", "(", "path", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ensureDir", "ensures", "the", "specified", "path", "is", "a", "directory", "or", "if", "it", "does", "not", "exist", "that", "a", "directory", "can", "be", "created", "there", "." ]

[ "func", "ensureEmptyDir", "(", "d", "dirFuncs", ",", "path", "string", ")", "error", "{", "fileCount", ",", "err", ":=", "d", ".", "fileCount", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "fileCount", ">", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ensureEmptyDir", "ensures", "the", "specified", "directory", "is", "empty", "." ]

[ "func", "(", "s", "*", "rootfsFilesystemSource", ")", "CreateFilesystems", "(", "ctx", "context", ".", "ProviderCallContext", ",", "args", "[", "]", "storage", ".", "FilesystemParams", ")", "(", "[", "]", "storage", ".", "CreateFilesystemsResult", ",", "error", ")", "{", "results", ":=", "make", "(", "[", "]", "storage", ".", "CreateFilesystemsResult", ",", "len", "(", "args", ")", ")", "\n", "for", "i", ",", "arg", ":=", "range", "args", "{", "filesystem", ",", "err", ":=", "s", ".", "createFilesystem", "(", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "err", "\n", "continue", "\n", "}", "\n", "results", "[", "i", "]", ".", "Filesystem", "=", "filesystem", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "CreateFilesystems", "is", "defined", "on", "the", "FilesystemSource", "interface", "." ]

[ "func", "(", "s", "*", "rootfsFilesystemSource", ")", "AttachFilesystems", "(", "ctx", "context", ".", "ProviderCallContext", ",", "args", "[", "]", "storage", ".", "FilesystemAttachmentParams", ")", "(", "[", "]", "storage", ".", "AttachFilesystemsResult", ",", "error", ")", "{", "results", ":=", "make", "(", "[", "]", "storage", ".", "AttachFilesystemsResult", ",", "len", "(", "args", ")", ")", "\n", "for", "i", ",", "arg", ":=", "range", "args", "{", "attachment", ",", "err", ":=", "s", ".", "attachFilesystem", "(", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "results", "[", "i", "]", ".", "Error", "=", "err", "\n", "continue", "\n", "}", "\n", "results", "[", "i", "]", ".", "FilesystemAttachment", "=", "attachment", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "AttachFilesystems", "is", "defined", "on", "the", "FilesystemSource", "interface", "." ]

[ "func", "NewLimitedContext", "(", "unitName", "string", ")", "*", "limitedContext", "{", "// TODO(fwereade): 2016-03-17 lp:1558657", "id", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "unitName", ",", "\"", "\"", ",", "rand", ".", "New", "(", "rand", ".", "NewSource", "(", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ")", ")", ".", "Int63", "(", ")", ")", "\n", "return", "&", "limitedContext", "{", "unitName", ":", "unitName", ",", "id", ":", "id", "}", "\n", "}" ]

[ "NewLimitedContext", "creates", "a", "new", "context", "that", "implements", "just", "the", "bare", "minimum", "of", "the", "hooks", ".", "Context", "interface", "." ]

[ "func", "(", "ctx", "*", "limitedContext", ")", "SetEnvVars", "(", "vars", "map", "[", "string", "]", "string", ")", "{", "if", "ctx", ".", "env", "==", "nil", "{", "ctx", ".", "env", "=", "vars", "\n", "return", "\n", "}", "\n", "for", "key", ",", "val", ":=", "range", "vars", "{", "ctx", ".", "env", "[", "key", "]", "=", "val", "\n", "}", "\n", "}" ]

[ "SetEnvVars", "sets", "additional", "environment", "variables", "to", "be", "exported", "by", "the", "context", "." ]

[ "func", "(", "a", "AuthTypes", ")", "Contains", "(", "t", "AuthType", ")", "bool", "{", "for", "_", ",", "v", ":=", "range", "a", "{", "if", "v", "==", "t", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Contains", "checks", "if", "AuthType", "t", "is", "in", "a", "AuthTypes", "." ]

[ "func", "RegionByName", "(", "regions", "[", "]", "Region", ",", "name", "string", ")", "(", "*", "Region", ",", "error", ")", "{", "for", "_", ",", "region", ":=", "range", "regions", "{", "if", "!", "strings", ".", "EqualFold", "(", "region", ".", "Name", ",", "name", ")", "{", "continue", "\n", "}", "\n", "return", "&", "region", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "NewNotFound", "(", "nil", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ",", "RegionNames", "(", "regions", ")", ",", ")", ")", "\n", "}" ]

[ "RegionByName", "finds", "the", "region", "in", "the", "given", "slice", "with", "the", "specified", "name", "with", "case", "folding", "." ]

[ "func", "RegionNames", "(", "regions", "[", "]", "Region", ")", "[", "]", "string", "{", "names", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "regions", ")", ")", "\n", "for", "i", ",", "region", ":=", "range", "regions", "{", "names", "[", "i", "]", "=", "region", ".", "Name", "\n", "}", "\n", "sort", ".", "Strings", "(", "names", ")", "\n", "return", "names", "\n", "}" ]

[ "RegionNames", "returns", "a", "sorted", "list", "of", "the", "names", "of", "the", "given", "regions", "." ]

[ "func", "PublicCloudMetadata", "(", "searchPath", "...", "string", ")", "(", "result", "map", "[", "string", "]", "Cloud", ",", "fallbackUsed", "bool", ",", "err", "error", ")", "{", "for", "_", ",", "file", ":=", "range", "searchPath", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "file", ")", "\n", "if", "err", "!=", "nil", "&&", "os", ".", "IsNotExist", "(", "err", ")", "{", "continue", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "clouds", ",", "err", ":=", "ParseCloudMetadata", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "clouds", ",", "false", ",", "err", "\n", "}", "\n", "clouds", ",", "err", ":=", "ParseCloudMetadata", "(", "[", "]", "byte", "(", "fallbackPublicCloudInfo", ")", ")", "\n", "return", "clouds", ",", "true", ",", "err", "\n", "}" ]

[ "PublicCloudMetadata", "looks", "in", "searchPath", "for", "cloud", "metadata", "files", "and", "if", "none", "are", "found", "returns", "the", "fallback", "public", "cloud", "metadata", "." ]

[ "func", "ParseOneCloud", "(", "data", "[", "]", "byte", ")", "(", "Cloud", ",", "error", ")", "{", "c", ":=", "&", "cloud", "{", "}", "\n", "if", "err", ":=", "yaml", ".", "Unmarshal", "(", "data", ",", "&", "c", ")", ";", "err", "!=", "nil", "{", "return", "Cloud", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "cloudFromInternal", "(", "c", ")", ",", "nil", "\n", "}" ]

[ "ParseOneCloud", "parses", "the", "given", "yaml", "bytes", "into", "a", "single", "Cloud", "metadata", "." ]

[ "func", "ParseCloudMetadata", "(", "data", "[", "]", "byte", ")", "(", "map", "[", "string", "]", "Cloud", ",", "error", ")", "{", "var", "metadata", "cloudSet", "\n", "if", "err", ":=", "yaml", ".", "Unmarshal", "(", "data", ",", "&", "metadata", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Translate to the exported type. For each cloud, we store", "// the first region for the cloud as its default region.", "clouds", ":=", "make", "(", "map", "[", "string", "]", "Cloud", ")", "\n", "for", "name", ",", "cloud", ":=", "range", "metadata", ".", "Clouds", "{", "details", ":=", "cloudFromInternal", "(", "cloud", ")", "\n", "details", ".", "Name", "=", "name", "\n", "if", "details", ".", "Description", "==", "\"", "\"", "{", "var", "ok", "bool", "\n", "if", "details", ".", "Description", ",", "ok", "=", "defaultCloudDescription", "[", "name", "]", ";", "!", "ok", "{", "details", ".", "Description", "=", "defaultCloudDescription", "[", "cloud", ".", "Type", "]", "\n", "}", "\n", "}", "\n", "clouds", "[", "name", "]", "=", "details", "\n", "}", "\n", "return", "clouds", ",", "nil", "\n", "}" ]

[ "ParseCloudMetadata", "parses", "the", "given", "yaml", "bytes", "into", "Clouds", "metadata", "." ]

[ "func", "WritePublicCloudMetadata", "(", "cloudsMap", "map", "[", "string", "]", "Cloud", ")", "error", "{", "data", ",", "err", ":=", "marshalCloudMetadata", "(", "cloudsMap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "utils", ".", "AtomicWriteFile", "(", "JujuPublicCloudsPath", "(", ")", ",", "data", ",", "0600", ")", "\n", "}" ]

[ "WritePublicCloudMetadata", "marshals", "to", "YAML", "and", "writes", "the", "cloud", "metadata", "to", "the", "public", "cloud", "file", "." ]

[ "func", "IsSameCloudMetadata", "(", "meta1", ",", "meta2", "map", "[", "string", "]", "Cloud", ")", "(", "bool", ",", "error", ")", "{", "// The easiest approach is to simply marshall to YAML and compare.", "yaml1", ",", "err", ":=", "marshalCloudMetadata", "(", "meta1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "yaml2", ",", "err", ":=", "marshalCloudMetadata", "(", "meta2", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "string", "(", "yaml1", ")", "==", "string", "(", "yaml2", ")", ",", "nil", "\n", "}" ]

[ "IsSameCloudMetadata", "returns", "true", "if", "both", "meta", "and", "meta2", "contain", "the", "same", "cloud", "metadata", "." ]

[ "func", "marshalCloudMetadata", "(", "cloudsMap", "map", "[", "string", "]", "Cloud", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "clouds", ":=", "cloudSet", "{", "make", "(", "map", "[", "string", "]", "*", "cloud", ")", "}", "\n", "for", "name", ",", "metadata", ":=", "range", "cloudsMap", "{", "clouds", ".", "Clouds", "[", "name", "]", "=", "cloudToInternal", "(", "metadata", ",", "false", ")", "\n", "}", "\n", "data", ",", "err", ":=", "yaml", ".", "Marshal", "(", "clouds", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "data", ",", "nil", "\n", "}" ]

[ "marshalCloudMetadata", "marshals", "the", "given", "clouds", "to", "YAML", "." ]

[ "func", "MarshalCloud", "(", "cloud", "Cloud", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "yaml", ".", "Marshal", "(", "cloudToInternal", "(", "cloud", ",", "true", ")", ")", "\n", "}" ]

[ "MarshalCloud", "marshals", "a", "Cloud", "to", "an", "opaque", "byte", "array", "." ]

[ "func", "UnmarshalCloud", "(", "in", "[", "]", "byte", ")", "(", "Cloud", ",", "error", ")", "{", "var", "internal", "cloud", "\n", "if", "err", ":=", "yaml", ".", "Unmarshal", "(", "in", ",", "&", "internal", ")", ";", "err", "!=", "nil", "{", "return", "Cloud", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "cloudFromInternal", "(", "&", "internal", ")", ",", "nil", "\n", "}" ]

[ "UnmarshalCloud", "unmarshals", "a", "Cloud", "from", "a", "byte", "array", "produced", "by", "MarshalCloud", "." ]

[ "func", "RegisterStructTags", "(", "vals", "...", "interface", "{", "}", ")", "{", "tags", ":=", "mkTags", "(", "vals", "...", ")", "\n", "for", "k", ",", "v", ":=", "range", "tags", "{", "tagsForType", "[", "k", "]", "=", "v", "\n", "}", "\n", "}" ]

[ "RegisterStructTags", "ensures", "the", "yaml", "tags", "for", "the", "given", "structs", "are", "able", "to", "be", "used", "when", "parsing", "cloud", "metadata", "." ]

[ "func", "yamlTags", "(", "t", "reflect", ".", "Type", ")", "map", "[", "string", "]", "int", "{", "if", "t", ".", "Kind", "(", ")", "!=", "reflect", ".", "Struct", "{", "panic", "(", "errors", ".", "Errorf", "(", "\"", "\"", ",", "t", ")", ")", "\n", "}", "\n", "tags", ":=", "make", "(", "map", "[", "string", "]", "int", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "t", ".", "NumField", "(", ")", ";", "i", "++", "{", "f", ":=", "t", ".", "Field", "(", "i", ")", "\n", "if", "f", ".", "Type", "!=", "reflect", ".", "TypeOf", "(", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "if", "tag", ":=", "f", ".", "Tag", ".", "Get", "(", "\"", "\"", ")", ";", "tag", "!=", "\"", "\"", "{", "if", "i", ":=", "strings", ".", "Index", "(", "tag", ",", "\"", "\"", ")", ";", "i", ">=", "0", "{", "tag", "=", "tag", "[", "0", ":", "i", "]", "\n", "}", "\n", "if", "tag", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "tag", "!=", "\"", "\"", "{", "f", ".", "Name", "=", "tag", "\n", "}", "\n", "}", "\n", "tags", "[", "f", ".", "Name", "]", "=", "i", "\n", "}", "\n", "return", "tags", "\n", "}" ]

[ "yamlTags", "returns", "a", "map", "from", "yaml", "tag", "to", "the", "field", "index", "for", "the", "string", "fields", "in", "the", "given", "type", "." ]

[ "func", "inherit", "(", "dst", ",", "src", "interface", "{", "}", ")", "{", "for", "tag", ":=", "range", "tags", "(", "dst", ")", "{", "setFieldByTag", "(", "dst", ",", "tag", ",", "fieldByTag", "(", "src", ",", "tag", ")", ",", "false", ")", "\n", "}", "\n", "}" ]

[ "inherit", "sets", "any", "blank", "fields", "in", "dst", "to", "their", "equivalent", "values", "in", "fields", "in", "src", "that", "have", "matching", "json", "tags", ".", "The", "dst", "parameter", "must", "be", "a", "pointer", "to", "a", "struct", "." ]

[ "func", "tags", "(", "x", "interface", "{", "}", ")", "map", "[", "string", "]", "int", "{", "t", ":=", "reflect", ".", "TypeOf", "(", "x", ")", "\n", "if", "t", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "t", "=", "t", ".", "Elem", "(", ")", "\n", "}", "\n", "if", "t", ".", "Kind", "(", ")", "!=", "reflect", ".", "Struct", "{", "panic", "(", "errors", ".", "Errorf", "(", "\"", "\"", ",", "t", ")", ")", "\n", "}", "\n\n", "if", "tagm", ":=", "tagsForType", "[", "t", "]", ";", "tagm", "!=", "nil", "{", "return", "tagm", "\n", "}", "\n", "panic", "(", "errors", ".", "Errorf", "(", "\"", "\"", ",", "t", ")", ")", "\n", "}" ]

[ "tags", "returns", "the", "field", "offsets", "for", "the", "JSON", "tags", "defined", "by", "the", "given", "value", "which", "must", "be", "a", "struct", "or", "a", "pointer", "to", "a", "struct", "." ]

[ "func", "fieldByTag", "(", "x", "interface", "{", "}", ",", "tag", "string", ")", "string", "{", "tagm", ":=", "tags", "(", "x", ")", "\n", "v", ":=", "reflect", ".", "ValueOf", "(", "x", ")", "\n", "if", "v", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "v", "=", "v", ".", "Elem", "(", ")", "\n", "}", "\n", "if", "i", ",", "ok", ":=", "tagm", "[", "tag", "]", ";", "ok", "{", "return", "v", ".", "Field", "(", "i", ")", ".", "Interface", "(", ")", ".", "(", "string", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "fieldByTag", "returns", "the", "value", "for", "the", "field", "in", "x", "with", "the", "given", "JSON", "tag", "or", "if", "there", "is", "no", "such", "field", "." ]

[ "func", "setFieldByTag", "(", "x", "interface", "{", "}", ",", "tag", ",", "val", "string", ",", "override", "bool", ")", "{", "i", ",", "ok", ":=", "tags", "(", "x", ")", "[", "tag", "]", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n", "v", ":=", "reflect", ".", "ValueOf", "(", "x", ")", ".", "Elem", "(", ")", "\n", "f", ":=", "v", ".", "Field", "(", "i", ")", "\n", "if", "override", "||", "f", ".", "Interface", "(", ")", ".", "(", "string", ")", "==", "\"", "\"", "{", "f", ".", "Set", "(", "reflect", ".", "ValueOf", "(", "val", ")", ")", "\n", "}", "\n", "}" ]

[ "setFieldByTag", "sets", "the", "value", "for", "the", "field", "in", "x", "with", "the", "given", "JSON", "tag", "to", "val", ".", "The", "override", "parameter", "specifies", "whether", "the", "value", "will", "be", "set", "even", "if", "the", "original", "value", "is", "non", "-", "empty", "." ]

[ "func", "NewAPI", "(", "caller", "base", ".", "APICaller", ")", "*", "API", "{", "facadeCaller", ":=", "base", ".", "NewFacadeCaller", "(", "caller", ",", "cleanerFacade", ")", "\n", "return", "&", "API", "{", "facade", ":", "facadeCaller", "}", "\n", "}" ]

[ "NewAPI", "creates", "a", "new", "client", "-", "side", "Cleaner", "facade", "." ]

[ "func", "(", "api", "*", "API", ")", "WatchCleanups", "(", ")", "(", "watcher", ".", "NotifyWatcher", ",", "error", ")", "{", "var", "result", "params", ".", "NotifyWatchResult", "\n", "err", ":=", "api", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "nil", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "result", ".", "Error", ";", "err", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n", "w", ":=", "apiwatcher", ".", "NewNotifyWatcher", "(", "api", ".", "facade", ".", "RawAPICaller", "(", ")", ",", "result", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "WatchCleanups", "calls", "the", "server", "-", "side", "WatchCleanups", "method", "." ]

[ "func", "(", "c", "Credential", ")", "MarshalYAML", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "credentialInternal", "{", "c", ".", "authType", ",", "c", ".", "attributes", "}", ",", "nil", "\n", "}" ]

[ "MarshalYAML", "implements", "the", "yaml", ".", "Marshaler", "interface", "." ]

[ "func", "(", "c", "*", "Credential", ")", "UnmarshalYAML", "(", "unmarshal", "func", "(", "interface", "{", "}", ")", "error", ")", "error", "{", "var", "internal", "credentialInternal", "\n", "if", "err", ":=", "unmarshal", "(", "&", "internal", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "*", "c", "=", "Credential", "{", "authType", ":", "internal", ".", "AuthType", ",", "attributes", ":", "internal", ".", "Attributes", "}", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalYAML", "implements", "the", "yaml", ".", "Marshaler", "interface", "." ]

[ "func", "NewCredential", "(", "authType", "AuthType", ",", "attributes", "map", "[", "string", "]", "string", ")", "Credential", "{", "return", "Credential", "{", "authType", ":", "authType", ",", "attributes", ":", "copyStringMap", "(", "attributes", ")", "}", "\n", "}" ]

[ "NewCredential", "returns", "a", "new", "immutable", "Credential", "with", "the", "supplied", "auth", "-", "type", "and", "attributes", "." ]

[ "func", "NewNamedCredential", "(", "name", "string", ",", "authType", "AuthType", ",", "attributes", "map", "[", "string", "]", "string", ",", "revoked", "bool", ")", "Credential", "{", "return", "Credential", "{", "Label", ":", "name", ",", "authType", ":", "authType", ",", "attributes", ":", "copyStringMap", "(", "attributes", ")", ",", "Revoked", ":", "revoked", ",", "}", "\n", "}" ]

[ "NewNamedCredential", "returns", "an", "immutable", "Credential", "with", "the", "supplied", "properties", "." ]

[ "func", "(", "s", "CredentialSchema", ")", "Attribute", "(", "name", "string", ")", "(", "*", "CredentialAttr", ",", "bool", ")", "{", "for", "_", ",", "value", ":=", "range", "s", "{", "if", "value", ".", "Name", "==", "name", "{", "result", ":=", "value", ".", "CredentialAttr", "\n", "return", "&", "result", ",", "true", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "Attribute", "returns", "the", "named", "CredentialAttr", "value", "." ]

[ "func", "FinalizeCredential", "(", "credential", "Credential", ",", "schemas", "map", "[", "AuthType", "]", "CredentialSchema", ",", "readFile", "func", "(", "string", ")", "(", "[", "]", "byte", ",", "error", ")", ",", ")", "(", "*", "Credential", ",", "error", ")", "{", "schema", ",", "ok", ":=", "schemas", "[", "credential", ".", "authType", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ",", "credential", ".", "authType", ")", "\n", "}", "\n", "attrs", ",", "err", ":=", "schema", ".", "Finalize", "(", "credential", ".", "attributes", ",", "readFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "Credential", "{", "authType", ":", "credential", ".", "authType", ",", "attributes", ":", "attrs", "}", ",", "nil", "\n", "}" ]

[ "FinalizeCredential", "finalizes", "a", "credential", "by", "matching", "it", "with", "one", "of", "the", "provided", "credential", "schemas", "and", "reading", "any", "file", "attributes", "into", "their", "corresponding", "non", "-", "file", "attributes", ".", "This", "will", "also", "validate", "the", "credential", ".", "If", "there", "is", "no", "schema", "with", "the", "matching", "auth", "-", "type", "an", "error", "satisfying", "errors", ".", "IsNotSupported", "will", "be", "returned", "." ]

[ "func", "(", "s", "CredentialSchema", ")", "Finalize", "(", "attrs", "map", "[", "string", "]", "string", ",", "readFile", "func", "(", "string", ")", "(", "[", "]", "byte", ",", "error", ")", ",", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "checker", ",", "err", ":=", "s", ".", "schemaChecker", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "m", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "k", ",", "v", ":=", "range", "attrs", "{", "m", "[", "k", "]", "=", "v", "\n", "}", "\n", "result", ",", "err", ":=", "checker", ".", "Coerce", "(", "m", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "resultMap", ":=", "result", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "newAttrs", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n\n", "// Construct the final credential attributes map, reading values from files as necessary.", "for", "_", ",", "field", ":=", "range", "s", "{", "if", "field", ".", "FileAttr", "!=", "\"", "\"", "{", "if", "err", ":=", "s", ".", "processFileAttrValue", "(", "field", ",", "resultMap", ",", "newAttrs", ",", "readFile", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "name", ":=", "field", ".", "Name", "\n", "if", "field", ".", "FilePath", "{", "pathValue", ",", "ok", ":=", "resultMap", "[", "name", "]", "\n", "if", "ok", "&&", "pathValue", "!=", "\"", "\"", "{", "absPath", ",", "err", ":=", "ValidateFileAttrValue", "(", "pathValue", ".", "(", "string", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "data", ",", "err", ":=", "readFile", "(", "absPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "if", "len", "(", "data", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "newAttrs", "[", "name", "]", "=", "string", "(", "data", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "if", "val", ",", "ok", ":=", "resultMap", "[", "name", "]", ";", "ok", "{", "newAttrs", "[", "name", "]", "=", "val", ".", "(", "string", ")", "\n", "}", "\n", "}", "\n", "return", "newAttrs", ",", "nil", "\n", "}" ]

[ "Finalize", "finalizes", "the", "given", "credential", "attributes", "against", "the", "credential", "schema", ".", "If", "the", "attributes", "are", "invalid", "Finalize", "will", "return", "an", "error", ".", "An", "updated", "attribute", "map", "will", "be", "returned", "having", "any", "file", "attributes", "deleted", "and", "replaced", "by", "their", "non", "-", "file", "counterparts", "with", "the", "values", "set", "to", "the", "contents", "of", "the", "files", "." ]

[ "func", "ValidateFileAttrValue", "(", "path", "string", ")", "(", "string", ",", "error", ")", "{", "absPath", ",", "err", ":=", "utils", ".", "ExpandPath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "info", ",", "err", ":=", "os", ".", "Stat", "(", "absPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "absPath", ")", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "absPath", ")", "\n", "}", "\n", "return", "absPath", ",", "nil", "\n", "}" ]

[ "ValidateFileAttrValue", "returns", "the", "normalised", "file", "path", "so", "long", "as", "the", "specified", "path", "is", "valid", "and", "not", "a", "directory", "." ]

[ "func", "ParseCredentials", "(", "data", "[", "]", "byte", ")", "(", "map", "[", "string", "]", "CloudCredential", ",", "error", ")", "{", "var", "credentialsYAML", "struct", "{", "Credentials", "map", "[", "string", "]", "interface", "{", "}", "`yaml:\"credentials\"`", "\n", "}", "\n", "err", ":=", "yaml", ".", "Unmarshal", "(", "data", ",", "&", "credentialsYAML", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "credentials", ":=", "make", "(", "map", "[", "string", "]", "CloudCredential", ")", "\n", "for", "cloud", ",", "v", ":=", "range", "credentialsYAML", ".", "Credentials", "{", "v", ",", "err", ":=", "cloudCredentialChecker", "{", "}", ".", "Coerce", "(", "v", ",", "[", "]", "string", "{", "\"", "\"", "+", "cloud", "}", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "credentials", "[", "cloud", "]", "=", "v", ".", "(", "CloudCredential", ")", "\n", "}", "\n", "return", "credentials", ",", "nil", "\n", "}" ]

[ "ParseCredentials", "parses", "the", "given", "yaml", "bytes", "into", "Credentials", "but", "does", "not", "validate", "the", "credential", "attributes", "." ]

[ "func", "RemoveSecrets", "(", "credential", "Credential", ",", "schemas", "map", "[", "AuthType", "]", "CredentialSchema", ",", ")", "(", "*", "Credential", ",", "error", ")", "{", "schema", ",", "ok", ":=", "schemas", "[", "credential", ".", "authType", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ",", "credential", ".", "authType", ")", "\n", "}", "\n", "redactedAttrs", ":=", "credential", ".", "Attributes", "(", ")", "\n", "for", "_", ",", "attr", ":=", "range", "schema", "{", "if", "attr", ".", "Hidden", "{", "delete", "(", "redactedAttrs", ",", "attr", ".", "Name", ")", "\n", "}", "\n", "}", "\n", "return", "&", "Credential", "{", "authType", ":", "credential", ".", "authType", ",", "attributes", ":", "redactedAttrs", "}", ",", "nil", "\n", "}" ]

[ "RemoveSecrets", "returns", "a", "copy", "of", "the", "given", "credential", "with", "secret", "fields", "removed", "." ]

[ "func", "New", "(", "callback", "func", "(", "string", ")", ")", "*", "StringForwarder", "{", "if", "callback", "==", "nil", "{", "// Nothing to forward to, so no need to start the loop().", "// We'll just count the discardCount.", "return", "&", "StringForwarder", "{", "stopped", ":", "true", "}", "\n", "}", "\n", "forwarder", ":=", "&", "StringForwarder", "{", "}", "\n", "forwarder", ".", "cond", "=", "sync", ".", "NewCond", "(", "&", "forwarder", ".", "mu", ")", "\n", "go", "forwarder", ".", "loop", "(", "callback", ")", "\n", "return", "forwarder", "\n", "}" ]

[ "New", "returns", "a", "new", "StringForwarder", "that", "sends", "messages", "to", "the", "callback", "function", "dropping", "messages", "if", "the", "receiver", "has", "not", "yet", "consumed", "the", "last", "message", "." ]

[ "func", "(", "f", "*", "StringForwarder", ")", "Forward", "(", "msg", "string", ")", "{", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "f", ".", "stopped", "||", "f", ".", "current", "!=", "nil", "{", "f", ".", "discardCount", "++", "\n", "}", "else", "{", "f", ".", "current", "=", "&", "msg", "\n", "f", ".", "cond", ".", "Signal", "(", ")", "\n", "}", "\n", "f", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Forward", "sends", "the", "message", "to", "be", "processed", "by", "the", "callback", "function", "discarding", "the", "message", "if", "another", "message", "is", "currently", "being", "processed", ".", "The", "number", "of", "discarded", "messages", "is", "recorded", "for", "reporting", "by", "the", "Stop", "method", ".", "Forward", "is", "safe", "to", "call", "from", "multiple", "goroutines", "at", "once", ".", "Note", "that", "if", "this", "StringForwarder", "was", "created", "with", "a", "nil", "callback", "all", "messages", "will", "be", "discarded", "." ]

[ "func", "(", "f", "*", "StringForwarder", ")", "Stop", "(", ")", "uint64", "{", "var", "count", "uint64", "\n", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "!", "f", ".", "stopped", "{", "f", ".", "stopped", "=", "true", "\n", "f", ".", "cond", ".", "Signal", "(", ")", "\n", "}", "\n", "count", "=", "f", ".", "discardCount", "\n", "f", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "count", "\n", "}" ]

[ "Stop", "cleans", "up", "the", "goroutine", "running", "behind", "StringForwarder", "and", "returns", "the", "count", "of", "discarded", "messages", ".", "Stop", "is", "thread", "-", "safe", "and", "may", "be", "called", "multiple", "times", "-", "after", "the", "first", "time", "it", "simply", "returns", "the", "current", "discard", "count", "." ]

[ "func", "(", "f", "*", "StringForwarder", ")", "loop", "(", "callback", "func", "(", "string", ")", ")", "{", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "f", ".", "mu", ".", "Unlock", "(", ")", "\n", "for", "{", "for", "!", "f", ".", "stopped", "&&", "f", ".", "current", "==", "nil", "{", "f", ".", "cond", ".", "Wait", "(", ")", "\n", "}", "\n", "if", "f", ".", "current", "==", "nil", "{", "return", "\n", "}", "\n", "f", ".", "invokeCallback", "(", "callback", ",", "*", "f", ".", "current", ")", "\n", "f", ".", "current", "=", "nil", "\n", "}", "\n", "}" ]

[ "loop", "invokes", "forwarded", "messages", "with", "the", "given", "callback", "until", "stopped", "." ]