Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.2k

[ "func", "(", "sb", "*", "storageBackend", ")", "AttachStorage", "(", "storage", "names", ".", "StorageTag", ",", "unit", "names", ".", "UnitTag", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "names", ".", "ReadableString", "(", "storage", ")", ",", "names", ".", "ReadableString", "(", "unit", ")", ",", ")", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "si", ",", "err", ":=", "sb", ".", "storageInstance", "(", "storage", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "u", ",", "err", ":=", "sb", ".", "unit", "(", "unit", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "u", ".", "Life", "(", ")", "!=", "Alive", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "ch", ",", "err", ":=", "u", ".", "charm", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "ops", ",", "err", ":=", "sb", ".", "attachStorageOps", "(", "si", ",", "u", ".", "UnitTag", "(", ")", ",", "u", ".", "Series", "(", ")", ",", "ch", ",", "u", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "si", ".", "doc", ".", "Owner", "==", "\"", "\"", "{", "// The storage instance will be owned by the unit, so we", "// must increment the unit's refcount for the storage name.", "//", "// Make sure that we *can* assign another storage instance", "// to the unit.", "_", ",", "currentCountOp", ",", "err", ":=", "validateStorageCountChange", "(", "sb", ",", "u", ".", "UnitTag", "(", ")", ",", "si", ".", "StorageName", "(", ")", ",", "1", ",", "ch", ".", "Meta", "(", ")", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "incRefOp", ",", "err", ":=", "increfEntityStorageOp", "(", "sb", ".", "mb", ",", "u", ".", "UnitTag", "(", ")", ",", "si", ".", "StorageName", "(", ")", ",", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "currentCountOp", ",", "incRefOp", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "unitsC", ",", "Id", ":", "u", ".", "doc", ".", "Name", ",", "Assert", ":", "isAliveDoc", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "}", "}", ",", "}", ")", "\n", "ops", "=", "append", "(", "ops", ",", "u", ".", "assertCharmOps", "(", "ch", ")", "...", ")", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "AttachStorage", "attaches", "storage", "to", "a", "unit", "creating", "and", "attaching", "machine", "storage", "as", "necessary", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "DestroyUnitStorageAttachments", "(", "unit", "names", ".", "UnitTag", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "unit", ".", "Id", "(", ")", ")", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "attachments", ",", "err", ":=", "sb", ".", "UnitStorageAttachments", "(", "unit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", ":=", "make", "(", "[", "]", "txn", ".", "Op", ",", "0", ",", "len", "(", "attachments", ")", ")", "\n", "for", "_", ",", "attachment", ":=", "range", "attachments", "{", "if", "attachment", ".", "Life", "(", ")", "!=", "Alive", "{", "continue", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "detachStorageOps", "(", "attachment", ".", "StorageInstance", "(", ")", ",", "unit", ",", ")", "...", ")", "\n", "}", "\n", "if", "len", "(", "ops", ")", "==", "0", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "DetachStorage", "ensures", "that", "the", "existing", "storage", "attachments", "of", "the", "specified", "unit", "are", "removed", "at", "some", "point", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "RemoveStorageAttachment", "(", "storage", "names", ".", "StorageTag", ",", "unit", "names", ".", "UnitTag", ",", "force", "bool", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "storage", ".", "Id", "(", ")", ",", "unit", ".", "Id", "(", ")", ")", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "s", ",", "err", ":=", "sb", ".", "storageAttachment", "(", "storage", ",", "unit", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "&&", "attempt", ">", "0", "{", "// On the first attempt, we expect it to exist.", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "s", ".", "doc", ".", "Life", "!=", "Dying", "{", "// TODO (anastasiamac 2019-04-05) We might want to ignore this when forcing...", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "inst", ",", "err", ":=", "sb", ".", "storageInstance", "(", "storage", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "// This implies that the attachment was removed", "// after the call to st.storageAttachment.", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", ",", "err", ":=", "removeStorageAttachmentOps", "(", "sb", ",", "s", ",", "inst", ",", "force", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "Dying", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "Remove", "removes", "the", "storage", "attachment", "from", "state", "and", "may", "remove", "its", "storage", "instance", "as", "well", "if", "the", "storage", "instance", "is", "Dying", "and", "no", "other", "references", "to", "it", "exist", ".", "It", "will", "fail", "if", "the", "storage", "attachment", "is", "not", "Dying", "." ]

[ "func", "removeStorageInstancesOps", "(", "im", "*", "storageBackend", ",", "owner", "names", ".", "Tag", ",", "force", "bool", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "coll", ",", "closer", ":=", "im", ".", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "storageInstancesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "docs", "[", "]", "storageInstanceDoc", "\n", "err", ":=", "coll", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "owner", ".", "String", "(", ")", "}", "}", ")", ".", "Select", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "true", "}", "}", ")", ".", "All", "(", "&", "docs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "owner", ")", "\n", "}", "\n", "ops", ":=", "make", "(", "[", "]", "txn", ".", "Op", ",", "0", ",", "len", "(", "docs", ")", ")", "\n", "var", "removalErr", "error", "\n", "for", "_", ",", "doc", ":=", "range", "docs", "{", "si", ":=", "&", "storageInstance", "{", "im", ",", "doc", "}", "\n", "storageInstanceOps", ",", "err", ":=", "removeStorageInstanceOps", "(", "si", ",", "nil", ",", "force", ")", "\n", "if", "err", "!=", "nil", "{", "removalErr", "=", "errors", ".", "Trace", "(", "err", ")", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "si", ".", "StorageTag", "(", ")", ".", "Id", "(", ")", ",", "err", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "storageInstanceOps", "...", ")", "\n", "}", "\n", "if", "!", "force", "&&", "removalErr", "!=", "nil", "{", "return", "nil", ",", "removalErr", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}" ]

[ "removeStorageInstancesOps", "returns", "the", "transaction", "operations", "to", "remove", "all", "storage", "instances", "owned", "by", "the", "specified", "entity", "." ]

[ "func", "validateStoragePool", "(", "sb", "*", "storageBackend", ",", "poolName", "string", ",", "kind", "storage", ".", "StorageKind", ",", "machineId", "*", "string", ",", ")", "error", "{", "if", "poolName", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "providerType", ",", "aProvider", ",", "poolConfig", ",", "err", ":=", "poolStorageProvider", "(", "sb", ",", "poolName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Ensure the storage provider supports the specified kind.", "kindSupported", ":=", "aProvider", ".", "Supports", "(", "kind", ")", "\n", "if", "!", "kindSupported", "&&", "kind", "==", "storage", ".", "StorageKindFilesystem", "{", "// Filesystems can be created if either filesystem", "// or block storage are supported. The scope of the", "// filesystem is the same as the backing volume.", "kindSupported", "=", "aProvider", ".", "Supports", "(", "storage", ".", "StorageKindBlock", ")", "\n", "}", "\n", "if", "!", "kindSupported", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "providerType", ",", "kind", ")", "\n", "}", "\n\n", "// Check the storage scope.", "if", "machineId", "!=", "nil", "{", "switch", "aProvider", ".", "Scope", "(", ")", "{", "case", "storage", ".", "ScopeMachine", ":", "if", "*", "machineId", "==", "\"", "\"", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "// The storage is not machine-scoped, so we clear out", "// the machine ID to inform the caller that the storage", "// scope should be the model.", "*", "machineId", "=", "\"", "\"", "\n", "}", "\n", "}", "\n\n", "// Validate any k8s config.", "if", "sb", ".", "modelType", "==", "ModelTypeCAAS", "{", "if", "err", ":=", "k8sprovider", ".", "ValidateStorageProvider", "(", "providerType", ",", "poolConfig", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "validateStoragePool", "validates", "the", "storage", "pool", "for", "the", "model", ".", "If", "machineId", "is", "non", "-", "nil", "the", "storage", "scope", "will", "be", "validated", "against", "the", "machineId", ";", "if", "the", "storage", "is", "not", "machine", "-", "scoped", "then", "the", "machineId", "will", "be", "updated", "to", "." ]

[ "func", "storageConstraintsWithDefaults", "(", "modelType", "ModelType", ",", "cfg", "*", "config", ".", "Config", ",", "charmStorage", "charm", ".", "Storage", ",", "name", "string", ",", "cons", "StorageConstraints", ",", ")", "(", "StorageConstraints", ",", "error", ")", "{", "withDefaults", ":=", "cons", "\n\n", "// If no pool is specified, determine the pool from the env config and other constraints.", "if", "cons", ".", "Pool", "==", "\"", "\"", "{", "kind", ":=", "storageKind", "(", "charmStorage", ".", "Type", ")", "\n", "poolName", ",", "err", ":=", "defaultStoragePool", "(", "modelType", ",", "cfg", ",", "kind", ",", "cons", ")", "\n", "if", "err", "!=", "nil", "{", "return", "withDefaults", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "withDefaults", ".", "Pool", "=", "poolName", "\n", "}", "\n\n", "// If no size is specified, we default to the min size specified by the", "// charm, or 1GiB.", "if", "cons", ".", "Size", "==", "0", "{", "if", "charmStorage", ".", "MinimumSize", ">", "0", "{", "withDefaults", ".", "Size", "=", "charmStorage", ".", "MinimumSize", "\n", "}", "else", "{", "withDefaults", ".", "Size", "=", "1024", "\n", "}", "\n", "}", "\n", "if", "cons", ".", "Count", "==", "0", "{", "withDefaults", ".", "Count", "=", "uint64", "(", "charmStorage", ".", "CountMin", ")", "\n", "}", "\n", "return", "withDefaults", ",", "nil", "\n", "}" ]

[ "storageConstraintsWithDefaults", "returns", "a", "constraints", "derived", "from", "cons", "with", "any", "defaults", "filled", "in", "." ]

[ "func", "defaultStoragePool", "(", "modelType", "ModelType", ",", "cfg", "*", "config", ".", "Config", ",", "kind", "storage", ".", "StorageKind", ",", "cons", "StorageConstraints", ")", "(", "string", ",", "error", ")", "{", "switch", "kind", "{", "case", "storage", ".", "StorageKindBlock", ":", "fallbackPool", ":=", "string", "(", "provider", ".", "LoopProviderType", ")", "\n", "if", "modelType", "==", "ModelTypeCAAS", "{", "fallbackPool", "=", "string", "(", "k8sprovider", ".", "K8s_ProviderType", ")", "\n", "}", "\n\n", "emptyConstraints", ":=", "StorageConstraints", "{", "}", "\n", "if", "cons", "==", "emptyConstraints", "{", "// No constraints at all: use fallback.", "return", "fallbackPool", ",", "nil", "\n", "}", "\n", "// Either size or count specified, use env default.", "defaultPool", ",", "ok", ":=", "cfg", ".", "StorageDefaultBlockSource", "(", ")", "\n", "if", "!", "ok", "{", "defaultPool", "=", "fallbackPool", "\n", "}", "\n", "return", "defaultPool", ",", "nil", "\n\n", "case", "storage", ".", "StorageKindFilesystem", ":", "fallbackPool", ":=", "string", "(", "provider", ".", "RootfsProviderType", ")", "\n", "if", "modelType", "==", "ModelTypeCAAS", "{", "fallbackPool", "=", "string", "(", "k8sprovider", ".", "K8s_ProviderType", ")", "\n", "}", "\n", "emptyConstraints", ":=", "StorageConstraints", "{", "}", "\n", "if", "cons", "==", "emptyConstraints", "{", "return", "fallbackPool", ",", "nil", "\n", "}", "\n\n", "// If a filesystem source is specified in config,", "// use that; otherwise if a block source is specified,", "// use that and create a filesystem within.", "defaultPool", ",", "ok", ":=", "cfg", ".", "StorageDefaultFilesystemSource", "(", ")", "\n", "if", "!", "ok", "{", "defaultPool", ",", "ok", "=", "cfg", ".", "StorageDefaultBlockSource", "(", ")", "\n", "if", "!", "ok", "{", "// No filesystem or block source,", "// so just use rootfs.", "defaultPool", "=", "fallbackPool", "\n", "}", "\n", "}", "\n", "return", "defaultPool", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "ErrNoDefaultStoragePool", "\n", "}" ]

[ "defaultStoragePool", "returns", "the", "default", "storage", "pool", "for", "the", "model", ".", "The", "default", "pool", "is", "either", "user", "specified", "or", "one", "that", "is", "registered", "by", "the", "provider", "itself", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "AddStorageForUnit", "(", "tag", "names", ".", "UnitTag", ",", "name", "string", ",", "cons", "StorageConstraints", ",", ")", "(", "[", "]", "names", ".", "StorageTag", ",", "error", ")", "{", "u", ",", "err", ":=", "sb", ".", "unit", "(", "tag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "var", "tags", "[", "]", "names", ".", "StorageTag", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "if", "attempt", ">", "0", "{", "if", "err", ":=", "u", ".", "Refresh", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "var", "ops", "[", "]", "txn", ".", "Op", "\n", "var", "err", "error", "\n", "tags", ",", "ops", ",", "err", "=", "sb", ".", "addStorageForUnitOps", "(", "u", ",", "name", ",", "cons", ")", "\n", "return", "ops", ",", "err", "\n", "}", "\n", "if", "err", ":=", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "name", ",", "u", ")", "\n", "}", "\n", "return", "tags", ",", "nil", "\n", "}" ]

[ "AddStorageForUnit", "adds", "storage", "instances", "to", "given", "unit", "as", "specified", ".", "Missing", "storage", "constraints", "are", "populated", "based", "on", "model", "defaults", ".", "Storage", "store", "name", "is", "used", "to", "retrieve", "existing", "storage", "instances", "for", "this", "store", ".", "Combination", "of", "existing", "storage", "instances", "and", "anticipated", "additional", "storage", "instances", "is", "validated", "against", "the", "store", "as", "specified", "in", "the", "charm", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "addStorageForUnitOps", "(", "u", "*", "Unit", ",", "storageName", "string", ",", "cons", "StorageConstraints", ",", ")", "(", "[", "]", "names", ".", "StorageTag", ",", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "if", "u", ".", "Life", "(", ")", "!=", "Alive", "{", "return", "nil", ",", "nil", ",", "unitNotAliveErr", "\n", "}", "\n\n", "// Storage addition is based on the charm metadata; u.charm()", "// returns txn.Ops that ensure the charm URL does not change", "// during the transaction.", "ch", ",", "err", ":=", "u", ".", "charm", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "charmMeta", ":=", "ch", ".", "Meta", "(", ")", "\n", "charmStorageMeta", ",", "ok", ":=", "charmMeta", ".", "Storage", "[", "storageName", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "storageName", ")", "\n", "}", "\n", "ops", ":=", "u", ".", "assertCharmOps", "(", "ch", ")", "\n\n", "if", "cons", ".", "Pool", "==", "\"", "\"", "||", "cons", ".", "Size", "==", "0", "{", "// Either pool or size, or both, were not specified. Take the", "// values from the unit's recorded storage constraints.", "allCons", ",", "err", ":=", "u", ".", "StorageConstraints", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "uCons", ",", "ok", ":=", "allCons", "[", "storageName", "]", ";", "ok", "{", "if", "cons", ".", "Pool", "==", "\"", "\"", "{", "cons", ".", "Pool", "=", "uCons", ".", "Pool", "\n", "}", "\n", "if", "cons", ".", "Size", "==", "0", "{", "cons", ".", "Size", "=", "uCons", ".", "Size", "\n", "}", "\n", "}", "\n\n", "// Populate missing configuration parameters with defaults.", "if", "cons", ".", "Pool", "==", "\"", "\"", "||", "cons", ".", "Size", "==", "0", "{", "modelConfig", ",", "err", ":=", "sb", ".", "config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "completeCons", ",", "err", ":=", "storageConstraintsWithDefaults", "(", "sb", ".", "modelType", ",", "modelConfig", ",", "charmStorageMeta", ",", "storageName", ",", "cons", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "cons", "=", "completeCons", "\n", "}", "\n", "}", "\n\n", "// This can happen for charm stores that specify instances range from 0,", "// and no count was specified at deploy as storage constraints for this store,", "// and no count was specified to storage add as a contraint either.", "if", "cons", ".", "Count", "==", "0", "{", "return", "nil", ",", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "tags", ",", "addUnitStorageOps", ",", "err", ":=", "sb", ".", "addUnitStorageOps", "(", "charmMeta", ",", "u", ",", "storageName", ",", "cons", ",", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "addUnitStorageOps", "...", ")", "\n", "return", "tags", ",", "ops", ",", "nil", "\n", "}" ]

[ "addStorage", "adds", "storage", "instances", "to", "given", "unit", "as", "specified", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "addUnitStorageOps", "(", "charmMeta", "*", "charm", ".", "Meta", ",", "u", "*", "Unit", ",", "storageName", "string", ",", "cons", "StorageConstraints", ",", "countMin", "int", ",", ")", "(", "[", "]", "names", ".", "StorageTag", ",", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "var", "ops", "[", "]", "txn", ".", "Op", "\n\n", "consTotal", ":=", "cons", "\n", "if", "countMin", "<", "0", "{", "// Validate that the requested number of storage", "// instances can be added to the unit.", "currentCount", ",", "currentCountOp", ",", "err", ":=", "validateStorageCountChange", "(", "sb", ",", "u", ".", "Tag", "(", ")", ",", "storageName", ",", "int", "(", "cons", ".", "Count", ")", ",", "charmMeta", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "currentCountOp", ")", "\n", "consTotal", ".", "Count", "+=", "uint64", "(", "currentCount", ")", "\n", "}", "else", "{", "currentCountOp", ",", "currentCount", ",", "err", ":=", "sb", ".", "countEntityStorageInstances", "(", "u", ".", "Tag", "(", ")", ",", "storageName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "currentCountOp", ")", "\n", "if", "currentCount", ">=", "countMin", "{", "return", "nil", ",", "ops", ",", "nil", "\n", "}", "\n", "cons", ".", "Count", "=", "uint64", "(", "countMin", ")", "\n", "}", "\n\n", "if", "err", ":=", "validateStorageConstraintsAgainstCharm", "(", "sb", ",", "map", "[", "string", "]", "StorageConstraints", "{", "storageName", ":", "consTotal", "}", ",", "charmMeta", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Create storage db operations", "storageOps", ",", "storageTags", ",", "_", ",", "err", ":=", "createStorageOps", "(", "sb", ",", "u", ".", "Tag", "(", ")", ",", "charmMeta", ",", "map", "[", "string", "]", "StorageConstraints", "{", "storageName", ":", "cons", "}", ",", "u", ".", "Series", "(", ")", ",", "u", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Increment reference counts for the named storage for each", "// instance we create. We'll use the reference counts to ensure", "// we don't exceed limits when adding storage, and for", "// maintaining model integrity during charm upgrades.", "var", "allTags", "[", "]", "names", ".", "StorageTag", "\n", "for", "name", ",", "tags", ":=", "range", "storageTags", "{", "count", ":=", "len", "(", "tags", ")", "\n", "incRefOp", ",", "err", ":=", "increfEntityStorageOp", "(", "sb", ".", "mb", ",", "u", ".", "Tag", "(", ")", ",", "name", ",", "count", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "storageOps", "=", "append", "(", "storageOps", ",", "incRefOp", ")", "\n", "allTags", "=", "append", "(", "allTags", ",", "tags", "...", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "unitsC", ",", "Id", ":", "u", ".", "doc", ".", "DocID", ",", "Assert", ":", "isAliveDoc", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "int", "(", "cons", ".", "Count", ")", "}", "}", "}", "}", ",", "}", ")", "\n", "return", "allTags", ",", "append", "(", "ops", ",", "storageOps", "...", ")", ",", "nil", "\n", "}" ]

[ "addUnitStorageOps", "returns", "transaction", "ops", "to", "create", "storage", "for", "the", "given", "unit", ".", "If", "countMin", "is", "non", "-", "negative", "the", "Count", "field", "of", "the", "constraints", "will", "be", "ignored", "and", "as", "many", "storage", "instances", "as", "necessary", "to", "make", "up", "the", "shortfall", "will", "be", "created", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "hostStorageOps", "(", "hostId", "string", ",", "args", "*", "storageParams", ",", ")", "(", "[", "]", "txn", ".", "Op", ",", "[", "]", "volumeAttachmentTemplate", ",", "[", "]", "filesystemAttachmentTemplate", ",", "error", ")", "{", "var", "filesystemOps", ",", "volumeOps", "[", "]", "txn", ".", "Op", "\n", "var", "fsAttachments", "[", "]", "filesystemAttachmentTemplate", "\n", "var", "volumeAttachments", "[", "]", "volumeAttachmentTemplate", "\n\n", "const", "(", "createAndAttach", "=", "false", "\n", "attachOnly", "=", "true", "\n", ")", "\n\n", "// Create filesystems and filesystem attachments.", "for", "_", ",", "f", ":=", "range", "args", ".", "filesystems", "{", "ops", ",", "filesystemTag", ",", "volumeTag", ",", "err", ":=", "sb", ".", "addFilesystemOps", "(", "f", ".", "Filesystem", ",", "hostId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "filesystemOps", "=", "append", "(", "filesystemOps", ",", "ops", "...", ")", "\n", "fsAttachments", "=", "append", "(", "fsAttachments", ",", "filesystemAttachmentTemplate", "{", "filesystemTag", ",", "f", ".", "Filesystem", ".", "storage", ",", "f", ".", "Attachment", ",", "createAndAttach", ",", "}", ")", "\n", "if", "volumeTag", "!=", "(", "names", ".", "VolumeTag", "{", "}", ")", "{", "// The filesystem requires a volume, so create a volume attachment too.", "volumeAttachments", "=", "append", "(", "volumeAttachments", ",", "volumeAttachmentTemplate", "{", "volumeTag", ",", "VolumeAttachmentParams", "{", "}", ",", "createAndAttach", ",", "}", ")", "\n", "}", "\n", "}", "\n", "for", "tag", ",", "filesystemAttachment", ":=", "range", "args", ".", "filesystemAttachments", "{", "fsAttachments", "=", "append", "(", "fsAttachments", ",", "filesystemAttachmentTemplate", "{", "tag", ",", "names", ".", "StorageTag", "{", "}", ",", "filesystemAttachment", ",", "attachOnly", ",", "}", ")", "\n", "}", "\n\n", "// Create volumes and volume attachments.", "for", "_", ",", "v", ":=", "range", "args", ".", "volumes", "{", "ops", ",", "tag", ",", "err", ":=", "sb", ".", "addVolumeOps", "(", "v", ".", "Volume", ",", "hostId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "volumeOps", "=", "append", "(", "volumeOps", ",", "ops", "...", ")", "\n", "volumeAttachments", "=", "append", "(", "volumeAttachments", ",", "volumeAttachmentTemplate", "{", "tag", ",", "v", ".", "Attachment", ",", "createAndAttach", ",", "}", ")", "\n", "}", "\n", "for", "tag", ",", "volumeAttachment", ":=", "range", "args", ".", "volumeAttachments", "{", "volumeAttachments", "=", "append", "(", "volumeAttachments", ",", "volumeAttachmentTemplate", "{", "tag", ",", "volumeAttachment", ",", "attachOnly", ",", "}", ")", "\n", "}", "\n\n", "ops", ":=", "make", "(", "[", "]", "txn", ".", "Op", ",", "0", ",", "len", "(", "filesystemOps", ")", "+", "len", "(", "volumeOps", ")", "+", "len", "(", "fsAttachments", ")", "+", "len", "(", "volumeAttachments", ")", ")", "\n", "if", "len", "(", "fsAttachments", ")", ">", "0", "{", "attachmentOps", ":=", "createMachineFilesystemAttachmentsOps", "(", "hostId", ",", "fsAttachments", ")", "\n", "ops", "=", "append", "(", "ops", ",", "filesystemOps", "...", ")", "\n", "ops", "=", "append", "(", "ops", ",", "attachmentOps", "...", ")", "\n", "}", "\n", "if", "len", "(", "volumeAttachments", ")", ">", "0", "{", "attachmentOps", ":=", "createMachineVolumeAttachmentsOps", "(", "hostId", ",", "volumeAttachments", ")", "\n", "ops", "=", "append", "(", "ops", ",", "volumeOps", "...", ")", "\n", "ops", "=", "append", "(", "ops", ",", "attachmentOps", "...", ")", "\n", "}", "\n", "return", "ops", ",", "volumeAttachments", ",", "fsAttachments", ",", "nil", "\n", "}" ]

[ "hostStorageOps", "creates", "txn", ".", "Ops", "for", "creating", "volumes", "filesystems", "and", "attachments", "to", "the", "specified", "host", ".", "The", "results", "are", "the", "txn", ".", "Ops", "and", "the", "tags", "of", "volumes", "and", "filesystems", "newly", "attached", "to", "the", "host", "." ]

[ "func", "addMachineStorageAttachmentsOps", "(", "machine", "*", "Machine", ",", "volumes", "[", "]", "volumeAttachmentTemplate", ",", "filesystems", "[", "]", "filesystemAttachmentTemplate", ",", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "var", "addToSet", "bson", ".", "D", "\n", "assert", ":=", "isAliveDoc", "\n", "if", "len", "(", "volumes", ")", ">", "0", "{", "volumeIds", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "volumes", ")", ")", "\n", "for", "i", ",", "v", ":=", "range", "volumes", "{", "volumeIds", "[", "i", "]", "=", "v", ".", "tag", ".", "Id", "(", ")", "\n", "}", "\n", "addToSet", "=", "append", "(", "addToSet", ",", "bson", ".", "DocElem", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "volumeIds", "}", "}", ",", "}", ")", "\n", "}", "\n", "if", "len", "(", "filesystems", ")", ">", "0", "{", "filesystemIds", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "filesystems", ")", ")", "\n", "var", "withLocation", "[", "]", "filesystemAttachmentTemplate", "\n", "for", "i", ",", "f", ":=", "range", "filesystems", "{", "filesystemIds", "[", "i", "]", "=", "f", ".", "tag", ".", "Id", "(", ")", "\n", "if", "!", "f", ".", "params", ".", "locationAutoGenerated", "{", "// If the location was not automatically", "// generated, we must ensure it does not", "// conflict with any existing storage.", "// Generated paths are guaranteed to be", "// unique.", "withLocation", "=", "append", "(", "withLocation", ",", "f", ")", "\n", "}", "\n", "}", "\n", "addToSet", "=", "append", "(", "addToSet", ",", "bson", ".", "DocElem", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "filesystemIds", "}", "}", ",", "}", ")", "\n", "if", "len", "(", "withLocation", ")", ">", "0", "{", "if", "err", ":=", "validateFilesystemMountPoints", "(", "machine", ",", "withLocation", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "// Make sure no filesystems are added concurrently.", "assert", "=", "append", "(", "assert", ",", "bson", ".", "DocElem", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "machine", ".", "doc", ".", "Filesystems", ",", "}", "}", ",", "}", "}", "}", "}", ",", "}", ")", "\n", "}", "\n", "}", "\n", "var", "update", "interface", "{", "}", "\n", "if", "len", "(", "addToSet", ")", ">", "0", "{", "update", "=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "addToSet", "}", "}", "\n", "}", "\n", "return", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "machinesC", ",", "Id", ":", "machine", ".", "doc", ".", "Id", ",", "Assert", ":", "assert", ",", "Update", ":", "update", ",", "}", "}", ",", "nil", "\n", "}" ]

[ "addMachineStorageAttachmentsOps", "returns", "txn", ".", "Ops", "for", "adding", "the", "IDs", "of", "attached", "volumes", "and", "filesystems", "to", "an", "existing", "machine", ".", "Filesystem", "mount", "points", "are", "checked", "against", "existing", "filesystem", "attachments", "for", "conflicts", "with", "a", "txn", ".", "Op", "added", "to", "prevent", "concurrent", "additions", "as", "necessary", "." ]

[ "func", "OpenSyslog", "(", "cfg", "*", "syslog", ".", "RawConfig", ")", "(", "*", "logforwarder", ".", "LogSink", ",", "error", ")", "{", "if", "!", "cfg", ".", "Enabled", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "client", ",", "err", ":=", "syslog", ".", "Open", "(", "*", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "client", "==", "nil", "{", "// TODO(axw) we should be returning an error", "// which we interpret up the stack.", "return", "&", "logforwarder", ".", "LogSink", "{", "SendCloser", ":", "emptySendCloser", "{", "}", ",", "}", ",", "nil", "\n", "}", "\n", "sink", ":=", "&", "logforwarder", ".", "LogSink", "{", "SendCloser", ":", "client", ",", "}", "\n", "return", "sink", ",", "nil", "\n", "}" ]

[ "OpenSyslog", "returns", "a", "sink", "used", "to", "receive", "log", "messages", "to", "be", "forwarded", "." ]

[ "func", "aboutToRestoreMethodsOnly", "(", "facadeName", "string", ",", "methodName", "string", ")", "error", "{", "fullName", ":=", "facadeName", "+", "\"", "\"", "+", "methodName", "\n", "if", "!", "allowedMethodsAboutToRestore", ".", "Contains", "(", "fullName", ")", "{", "return", "aboutToRestoreError", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "aboutToRestoreMethodsOnly", "can", "be", "used", "with", "restrictRoot", "to", "restrict", "the", "API", "to", "the", "methods", "allowed", "when", "the", "server", "is", "in", "state", ".", "RestorePreparing", "mode", "." ]

[ "func", "NewMockServiceAccountInterface", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockServiceAccountInterface", "{", "mock", ":=", "&", "MockServiceAccountInterface", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockServiceAccountInterfaceMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockServiceAccountInterface", ")", "CreateToken", "(", "arg0", "string", ",", "arg1", "*", "v1", ".", "TokenRequest", ")", "(", "*", "v1", ".", "TokenRequest", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "*", "v1", ".", "TokenRequest", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "CreateToken", "mocks", "base", "method" ]

[ "func", "FromNetworkPort", "(", "p", "corenetwork", ".", "Port", ")", "Port", "{", "return", "Port", "{", "Protocol", ":", "p", ".", "Protocol", ",", "Number", ":", "p", ".", "Number", ",", "}", "\n", "}" ]

[ "FromNetworkPort", "is", "a", "convenience", "helper", "to", "create", "a", "parameter", "out", "of", "the", "network", "type", "here", "for", "Port", "." ]

[ "func", "(", "p", "Port", ")", "NetworkPort", "(", ")", "corenetwork", ".", "Port", "{", "return", "corenetwork", ".", "Port", "{", "Protocol", ":", "p", ".", "Protocol", ",", "Number", ":", "p", ".", "Number", ",", "}", "\n", "}" ]

[ "NetworkPort", "is", "a", "convenience", "helper", "to", "return", "the", "parameter", "as", "network", "type", "here", "for", "Port", "." ]

[ "func", "FromNetworkPortRange", "(", "pr", "corenetwork", ".", "PortRange", ")", "PortRange", "{", "return", "PortRange", "{", "FromPort", ":", "pr", ".", "FromPort", ",", "ToPort", ":", "pr", ".", "ToPort", ",", "Protocol", ":", "pr", ".", "Protocol", ",", "}", "\n", "}" ]

[ "FromNetworkPortRange", "is", "a", "convenience", "helper", "to", "create", "a", "parameter", "out", "of", "the", "network", "type", "here", "for", "PortRange", "." ]

[ "func", "(", "pr", "PortRange", ")", "NetworkPortRange", "(", ")", "corenetwork", ".", "PortRange", "{", "return", "corenetwork", ".", "PortRange", "{", "FromPort", ":", "pr", ".", "FromPort", ",", "ToPort", ":", "pr", ".", "ToPort", ",", "Protocol", ":", "pr", ".", "Protocol", ",", "}", "\n", "}" ]

[ "NetworkPortRange", "is", "a", "convenience", "helper", "to", "return", "the", "parameter", "as", "network", "type", "here", "for", "PortRange", "." ]

[ "func", "FromNetworkAddress", "(", "naddr", "network", ".", "Address", ")", "Address", "{", "return", "Address", "{", "Value", ":", "naddr", ".", "Value", ",", "Type", ":", "string", "(", "naddr", ".", "Type", ")", ",", "Scope", ":", "string", "(", "naddr", ".", "Scope", ")", ",", "SpaceName", ":", "string", "(", "naddr", ".", "SpaceName", ")", ",", "}", "\n", "}" ]

[ "FromNetworkAddress", "is", "a", "convenience", "helper", "to", "create", "a", "parameter", "out", "of", "the", "network", "type", "here", "for", "Address", "." ]

[ "func", "(", "addr", "Address", ")", "NetworkAddress", "(", ")", "network", ".", "Address", "{", "return", "network", ".", "Address", "{", "Value", ":", "addr", ".", "Value", ",", "Type", ":", "network", ".", "AddressType", "(", "addr", ".", "Type", ")", ",", "Scope", ":", "network", ".", "Scope", "(", "addr", ".", "Scope", ")", ",", "SpaceName", ":", "network", ".", "SpaceName", "(", "addr", ".", "SpaceName", ")", ",", "}", "\n", "}" ]

[ "NetworkAddress", "is", "a", "convenience", "helper", "to", "return", "the", "parameter", "as", "network", "type", "here", "for", "Address", "." ]

[ "func", "FromNetworkAddresses", "(", "naddrs", "...", "network", ".", "Address", ")", "[", "]", "Address", "{", "addrs", ":=", "make", "(", "[", "]", "Address", ",", "len", "(", "naddrs", ")", ")", "\n", "for", "i", ",", "naddr", ":=", "range", "naddrs", "{", "addrs", "[", "i", "]", "=", "FromNetworkAddress", "(", "naddr", ")", "\n", "}", "\n", "return", "addrs", "\n", "}" ]

[ "FromNetworkAddresses", "is", "a", "convenience", "helper", "to", "create", "a", "parameter", "out", "of", "the", "network", "type", "here", "for", "a", "slice", "of", "Address", "." ]

[ "func", "NetworkAddresses", "(", "addrs", "...", "Address", ")", "[", "]", "network", ".", "Address", "{", "naddrs", ":=", "make", "(", "[", "]", "network", ".", "Address", ",", "len", "(", "addrs", ")", ")", "\n", "for", "i", ",", "addr", ":=", "range", "addrs", "{", "naddrs", "[", "i", "]", "=", "addr", ".", "NetworkAddress", "(", ")", "\n", "}", "\n", "return", "naddrs", "\n", "}" ]

[ "NetworkAddresses", "is", "a", "convenience", "helper", "to", "return", "the", "parameter", "as", "network", "type", "here", "for", "a", "slice", "of", "Address", "." ]

[ "func", "FromNetworkHostPort", "(", "nhp", "network", ".", "HostPort", ")", "HostPort", "{", "return", "HostPort", "{", "FromNetworkAddress", "(", "nhp", ".", "Address", ")", ",", "nhp", ".", "Port", "}", "\n", "}" ]

[ "FromNetworkHostPort", "is", "a", "convenience", "helper", "to", "create", "a", "parameter", "out", "of", "the", "network", "type", "here", "for", "HostPort", "." ]

[ "func", "(", "hp", "HostPort", ")", "NetworkHostPort", "(", ")", "network", ".", "HostPort", "{", "return", "network", ".", "HostPort", "{", "hp", ".", "Address", ".", "NetworkAddress", "(", ")", ",", "hp", ".", "Port", "}", "\n", "}" ]

[ "NetworkHostPort", "is", "a", "convenience", "helper", "to", "return", "the", "parameter", "as", "network", "type", "here", "for", "HostPort", "." ]

[ "func", "FromNetworkHostPorts", "(", "nhps", "[", "]", "network", ".", "HostPort", ")", "[", "]", "HostPort", "{", "hps", ":=", "make", "(", "[", "]", "HostPort", ",", "len", "(", "nhps", ")", ")", "\n", "for", "i", ",", "nhp", ":=", "range", "nhps", "{", "hps", "[", "i", "]", "=", "FromNetworkHostPort", "(", "nhp", ")", "\n", "}", "\n", "return", "hps", "\n", "}" ]

[ "FromNetworkHostPorts", "is", "a", "helper", "to", "create", "a", "parameter", "out", "of", "the", "network", "type", "here", "for", "a", "slice", "of", "HostPort", "." ]

[ "func", "NetworkHostPorts", "(", "hps", "[", "]", "HostPort", ")", "[", "]", "network", ".", "HostPort", "{", "nhps", ":=", "make", "(", "[", "]", "network", ".", "HostPort", ",", "len", "(", "hps", ")", ")", "\n", "for", "i", ",", "hp", ":=", "range", "hps", "{", "nhps", "[", "i", "]", "=", "hp", ".", "NetworkHostPort", "(", ")", "\n", "}", "\n", "return", "nhps", "\n", "}" ]

[ "NetworkHostPorts", "is", "a", "convenience", "helper", "to", "return", "the", "parameter", "as", "network", "type", "here", "for", "a", "slice", "of", "HostPort", "." ]

[ "func", "FromNetworkHostsPorts", "(", "nhpm", "[", "]", "[", "]", "network", ".", "HostPort", ")", "[", "]", "[", "]", "HostPort", "{", "hpm", ":=", "make", "(", "[", "]", "[", "]", "HostPort", ",", "len", "(", "nhpm", ")", ")", "\n", "for", "i", ",", "nhps", ":=", "range", "nhpm", "{", "hpm", "[", "i", "]", "=", "FromNetworkHostPorts", "(", "nhps", ")", "\n", "}", "\n", "return", "hpm", "\n", "}" ]

[ "FromNetworkHostsPorts", "is", "a", "helper", "to", "create", "a", "parameter", "out", "of", "the", "network", "type", "here", "for", "a", "nested", "slice", "of", "HostPort", "." ]

[ "func", "NetworkHostsPorts", "(", "hpm", "[", "]", "[", "]", "HostPort", ")", "[", "]", "[", "]", "network", ".", "HostPort", "{", "nhpm", ":=", "make", "(", "[", "]", "[", "]", "network", ".", "HostPort", ",", "len", "(", "hpm", ")", ")", "\n", "for", "i", ",", "hps", ":=", "range", "hpm", "{", "nhpm", "[", "i", "]", "=", "NetworkHostPorts", "(", "hps", ")", "\n", "}", "\n", "return", "nhpm", "\n", "}" ]

[ "NetworkHostsPorts", "is", "a", "convenience", "helper", "to", "return", "the", "parameter", "as", "network", "type", "here", "for", "a", "nested", "slice", "of", "HostPort", "." ]

[ "func", "stateStepsFor25", "(", ")", "[", "]", "Step", "{", "return", "[", "]", "Step", "{", "&", "upgradeStep", "{", "description", ":", "`migrate storage records to use \"hostid\" field`", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "MigrateStorageMachineIdFields", "(", ")", "\n", "}", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "Controller", "}", ",", "run", ":", "MigrateLegacyLeases", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "MigrateAddModelPermissions", "(", ")", "\n", "}", ",", "}", ",", "&", "upgradeStep", "{", "description", ":", "\"", "\"", ",", "targets", ":", "[", "]", "Target", "{", "DatabaseMaster", "}", ",", "run", ":", "func", "(", "context", "Context", ")", "error", "{", "return", "context", ".", "State", "(", ")", ".", "SetEnableDiskUUIDOnVsphere", "(", ")", "\n", "}", ",", "}", ",", "}", "\n", "}" ]

[ "stateStepsFor25", "returns", "upgrade", "steps", "for", "Juju", "2", ".", "5", ".", "0", "that", "manipulate", "state", "directly", "." ]

[ "func", "newAPIHandler", "(", "srv", "*", "Server", ",", "st", "*", "state", ".", "State", ",", "rpcConn", "*", "rpc", ".", "Conn", ",", "modelUUID", "string", ",", "connectionID", "uint64", ",", "serverHost", "string", ")", "(", "*", "apiHandler", ",", "error", ")", "{", "m", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// If this model used to be hosted on this controller but got", "// migrated allow clients to connect and wait for a login", "// request to decide whether the users should be redirected to", "// the new controller for this model or not.", "if", "_", ",", "migErr", ":=", "st", ".", "LatestRemovedModelMigration", "(", ")", ";", "migErr", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "// return original NotFound error", "\n", "}", "\n", "}", "\n\n", "r", ":=", "&", "apiHandler", "{", "state", ":", "st", ",", "model", ":", "m", ",", "resources", ":", "common", ".", "NewResources", "(", ")", ",", "shared", ":", "srv", ".", "shared", ",", "rpcConn", ":", "rpcConn", ",", "modelUUID", ":", "modelUUID", ",", "connectionID", ":", "connectionID", ",", "serverHost", ":", "serverHost", ",", "}", "\n\n", "if", "err", ":=", "r", ".", "resources", ".", "RegisterNamed", "(", "\"", "\"", ",", "common", ".", "StringResource", "(", "srv", ".", "tag", ".", "Id", "(", ")", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "r", ".", "resources", ".", "RegisterNamed", "(", "\"", "\"", ",", "common", ".", "StringResource", "(", "srv", ".", "dataDir", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "r", ".", "resources", ".", "RegisterNamed", "(", "\"", "\"", ",", "common", ".", "StringResource", "(", "srv", ".", "logDir", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Facades involved with managing application offers need the auth context", "// to mint and validate macaroons.", "localOfferAccessEndpoint", ":=", "url", ".", "URL", "{", "Scheme", ":", "\"", "\"", ",", "Host", ":", "serverHost", ",", "Path", ":", "localOfferAccessLocationPath", ",", "}", "\n", "offerAuthCtxt", ":=", "srv", ".", "offerAuthCtxt", ".", "WithDischargeURL", "(", "localOfferAccessEndpoint", ".", "String", "(", ")", ")", "\n", "if", "err", ":=", "r", ".", "resources", ".", "RegisterNamed", "(", "\"", "\"", ",", "common", ".", "ValueResource", "{", "Value", ":", "offerAuthCtxt", "}", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "r", ",", "nil", "\n", "}" ]

[ "newAPIHandler", "returns", "a", "new", "apiHandler", "." ]

[ "func", "(", "s", "*", "srvCaller", ")", "Call", "(", "ctx", "context", ".", "Context", ",", "objId", "string", ",", "arg", "reflect", ".", "Value", ")", "(", "reflect", ".", "Value", ",", "error", ")", "{", "objVal", ",", "err", ":=", "s", ".", "creator", "(", "objId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "reflect", ".", "Value", "{", "}", ",", "err", "\n", "}", "\n", "return", "s", ".", "objMethod", ".", "Call", "(", "ctx", ",", "objVal", ",", "arg", ")", "\n", "}" ]

[ "Call", "takes", "the", "object", "Id", "and", "an", "instance", "of", "ParamsType", "to", "create", "an", "object", "and", "place", "a", "call", "on", "its", "method", ".", "It", "then", "returns", "an", "instance", "of", "ResultType", "." ]

[ "func", "newAPIRoot", "(", "st", "*", "state", ".", "State", ",", "shared", "*", "sharedServerContext", ",", "facades", "*", "facade", ".", "Registry", ",", "resources", "*", "common", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ")", "*", "apiRoot", "{", "r", ":=", "&", "apiRoot", "{", "state", ":", "st", ",", "shared", ":", "shared", ",", "facades", ":", "facades", ",", "resources", ":", "resources", ",", "authorizer", ":", "authorizer", ",", "objectCache", ":", "make", "(", "map", "[", "objectKey", "]", "reflect", ".", "Value", ")", ",", "}", "\n", "return", "r", "\n", "}" ]

[ "newAPIRoot", "returns", "a", "new", "apiRoot", "." ]

[ "func", "restrictAPIRoot", "(", "srv", "*", "Server", ",", "apiRoot", "rpc", ".", "Root", ",", "model", "*", "state", ".", "Model", ",", "auth", "authResult", ",", ")", "(", "rpc", ".", "Root", ",", "error", ")", "{", "if", "!", "auth", ".", "controllerMachineLogin", "{", "// Controller agents are allowed to", "// connect even during maintenance.", "restrictedRoot", ",", "err", ":=", "restrictAPIRootDuringMaintenance", "(", "srv", ",", "apiRoot", ",", "model", ",", "auth", ".", "tag", ",", "auth", ".", "controllerMachineLogin", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "apiRoot", "=", "restrictedRoot", "\n", "}", "\n", "if", "auth", ".", "controllerOnlyLogin", "{", "apiRoot", "=", "restrictRoot", "(", "apiRoot", ",", "controllerFacadesOnly", ")", "\n", "}", "else", "{", "apiRoot", "=", "restrictRoot", "(", "apiRoot", ",", "modelFacadesOnly", ")", "\n", "if", "model", ".", "Type", "(", ")", "==", "state", ".", "ModelTypeCAAS", "{", "apiRoot", "=", "restrictRoot", "(", "apiRoot", ",", "caasModelFacadesOnly", ")", "\n", "}", "\n", "}", "\n", "return", "apiRoot", ",", "nil", "\n", "}" ]

[ "restrictAPIRoot", "calls", "restrictAPIRootDuringMaintenance", "and", "then", "restricts", "the", "result", "further", "to", "the", "controller", "or", "model", "facades", "depending", "on", "the", "type", "of", "login", "." ]

[ "func", "(", "ctx", "*", "facadeContext", ")", "ModelPresence", "(", "modelUUID", "string", ")", "facade", ".", "ModelPresence", "{", "if", "ctx", ".", "r", ".", "shared", ".", "featureEnabled", "(", "feature", ".", "OldPresence", ")", "{", "// Used in common/presence.go to determine which code path to follow.", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "r", ".", "shared", ".", "presence", ".", "Connections", "(", ")", ".", "ForModel", "(", "modelUUID", ")", "\n", "}" ]

[ "ModelPresence", "implements", "facade", ".", "ModelPresence", "." ]

[ "func", "(", "ctx", "*", "facadeContext", ")", "LeadershipClaimer", "(", "modelUUID", "string", ")", "(", "leadership", ".", "Claimer", ",", "error", ")", "{", "if", "ctx", ".", "r", ".", "shared", ".", "featureEnabled", "(", "feature", ".", "LegacyLeases", ")", "{", "if", "modelUUID", "!=", "ctx", ".", "State", "(", ")", ".", "ModelUUID", "(", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "ctx", ".", "State", "(", ")", ".", "LeadershipClaimer", "(", ")", ",", "nil", "\n", "}", "\n", "claimer", ",", "err", ":=", "ctx", ".", "r", ".", "shared", ".", "leaseManager", ".", "Claimer", "(", "lease", ".", "ApplicationLeadershipNamespace", ",", "modelUUID", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "leadershipClaimer", "{", "claimer", "}", ",", "nil", "\n", "}" ]

[ "LeadershipClaimer", "is", "part", "of", "the", "facade", ".", "Context", "interface", ".", "Getting", "a", "claimer", "for", "an", "arbitrary", "model", "is", "only", "supported", "for", "raft", "leases", "-", "only", "a", "claimer", "for", "the", "current", "model", "can", "be", "obtained", "with", "legacy", "leases", "." ]

[ "func", "(", "ctx", "*", "facadeContext", ")", "LeadershipChecker", "(", ")", "(", "leadership", ".", "Checker", ",", "error", ")", "{", "if", "ctx", ".", "r", ".", "shared", ".", "featureEnabled", "(", "feature", ".", "LegacyLeases", ")", "{", "return", "ctx", ".", "State", "(", ")", ".", "LeadershipChecker", "(", ")", ",", "nil", "\n", "}", "\n", "checker", ",", "err", ":=", "ctx", ".", "r", ".", "shared", ".", "leaseManager", ".", "Checker", "(", "lease", ".", "ApplicationLeadershipNamespace", ",", "ctx", ".", "State", "(", ")", ".", "ModelUUID", "(", ")", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "leadershipChecker", "{", "checker", "}", ",", "nil", "\n", "}" ]

[ "LeadershipChecker", "is", "part", "of", "the", "facade", ".", "Context", "interface", "." ]

[ "func", "(", "ctx", "*", "facadeContext", ")", "LeadershipPinner", "(", "modelUUID", "string", ")", "(", "leadership", ".", "Pinner", ",", "error", ")", "{", "if", "ctx", ".", "r", ".", "shared", ".", "featureEnabled", "(", "feature", ".", "LegacyLeases", ")", "{", "return", "nil", ",", "errors", ".", "NotImplementedf", "(", "\"", "\"", ")", "\n", "}", "\n", "pinner", ",", "err", ":=", "ctx", ".", "r", ".", "shared", ".", "leaseManager", ".", "Pinner", "(", "lease", ".", "ApplicationLeadershipNamespace", ",", "modelUUID", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "leadershipPinner", "{", "pinner", "}", ",", "nil", "\n", "}" ]

[ "LeadershipPinner", "is", "part", "of", "the", "facade", ".", "Context", "interface", ".", "Pinning", "functionality", "is", "only", "available", "with", "the", "Raft", "leases", "implementation", "." ]

[ "func", "(", "ctx", "*", "facadeContext", ")", "LeadershipReader", "(", "modelUUID", "string", ")", "(", "leadership", ".", "Reader", ",", "error", ")", "{", "if", "ctx", ".", "r", ".", "shared", ".", "featureEnabled", "(", "feature", ".", "LegacyLeases", ")", "{", "return", "legacyLeadershipReader", "{", "ctx", ".", "State", "(", ")", "}", ",", "nil", "\n", "}", "\n", "reader", ",", "err", ":=", "ctx", ".", "r", ".", "shared", ".", "leaseManager", ".", "Reader", "(", "lease", ".", "ApplicationLeadershipNamespace", ",", "modelUUID", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "leadershipReader", "{", "reader", "}", ",", "nil", "\n", "}" ]

[ "LeadershipReader", "is", "part", "of", "the", "facade", ".", "Context", "interface", ".", "It", "returns", "a", "reader", "that", "can", "be", "used", "to", "return", "all", "application", "leaders", "in", "the", "model", "." ]

[ "func", "(", "ctx", "*", "facadeContext", ")", "SingularClaimer", "(", ")", "(", "lease", ".", "Claimer", ",", "error", ")", "{", "if", "ctx", ".", "r", ".", "shared", ".", "featureEnabled", "(", "feature", ".", "LegacyLeases", ")", "{", "return", "ctx", ".", "State", "(", ")", ".", "SingularClaimer", "(", ")", ",", "nil", "\n", "}", "\n", "return", "ctx", ".", "r", ".", "shared", ".", "leaseManager", ".", "Claimer", "(", "lease", ".", "SingularControllerNamespace", ",", "ctx", ".", "State", "(", ")", ".", "ModelUUID", "(", ")", ",", ")", "\n", "}" ]

[ "SingularClaimer", "is", "part", "of", "the", "facade", ".", "Context", "interface", "." ]

[ "func", "newAdminRoot", "(", "h", "*", "apiHandler", ",", "adminAPIs", "map", "[", "int", "]", "interface", "{", "}", ")", "*", "adminRoot", "{", "r", ":=", "&", "adminRoot", "{", "apiHandler", ":", "h", ",", "adminAPIs", ":", "adminAPIs", ",", "}", "\n", "return", "r", "\n", "}" ]

[ "newAdminRoot", "creates", "a", "new", "AnonRoot", "which", "dispatches", "to", "the", "given", "Admin", "API", "implementation", "." ]

[ "func", "(", "r", "*", "apiHandler", ")", "AuthMachineAgent", "(", ")", "bool", "{", "_", ",", "isMachine", ":=", "r", ".", "GetAuthTag", "(", ")", ".", "(", "names", ".", "MachineTag", ")", "\n", "return", "isMachine", "\n", "}" ]

[ "AuthMachineAgent", "returns", "whether", "the", "current", "client", "is", "a", "machine", "agent", "." ]

[ "func", "(", "r", "*", "apiHandler", ")", "AuthApplicationAgent", "(", ")", "bool", "{", "_", ",", "isApp", ":=", "r", ".", "GetAuthTag", "(", ")", ".", "(", "names", ".", "ApplicationTag", ")", "\n", "return", "isApp", "\n", "}" ]

[ "AuthApplicationAgent", "returns", "whether", "the", "current", "client", "is", "an", "application", "operator", "." ]

[ "func", "(", "r", "*", "apiHandler", ")", "AuthUnitAgent", "(", ")", "bool", "{", "_", ",", "isUnit", ":=", "r", ".", "GetAuthTag", "(", ")", ".", "(", "names", ".", "UnitTag", ")", "\n", "return", "isUnit", "\n", "}" ]

[ "AuthUnitAgent", "returns", "whether", "the", "current", "client", "is", "a", "unit", "agent", "." ]

[ "func", "(", "r", "*", "apiHandler", ")", "AuthOwner", "(", "tag", "names", ".", "Tag", ")", "bool", "{", "return", "r", ".", "entity", ".", "Tag", "(", ")", "==", "tag", "\n", "}" ]

[ "AuthOwner", "returns", "whether", "the", "authenticated", "user", "s", "tag", "matches", "the", "given", "entity", "tag", "." ]

[ "func", "(", "r", "*", "apiHandler", ")", "AuthController", "(", ")", "bool", "{", "type", "hasIsManager", "interface", "{", "IsManager", "(", ")", "bool", "\n", "}", "\n", "m", ",", "ok", ":=", "r", ".", "entity", ".", "(", "hasIsManager", ")", "\n", "return", "ok", "&&", "m", ".", "IsManager", "(", ")", "\n", "}" ]

[ "AuthController", "returns", "whether", "the", "authenticated", "user", "is", "a", "machine", "with", "running", "the", "ManageEnviron", "job", "." ]

[ "func", "(", "r", "*", "apiHandler", ")", "AuthClient", "(", ")", "bool", "{", "_", ",", "isUser", ":=", "r", ".", "GetAuthTag", "(", ")", ".", "(", "names", ".", "UserTag", ")", "\n", "return", "isUser", "\n", "}" ]

[ "AuthClient", "returns", "whether", "the", "authenticated", "entity", "is", "a", "client", "user", "." ]

[ "func", "(", "r", "*", "apiHandler", ")", "GetAuthTag", "(", ")", "names", ".", "Tag", "{", "if", "r", ".", "entity", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "r", ".", "entity", ".", "Tag", "(", ")", "\n", "}" ]

[ "GetAuthTag", "returns", "the", "tag", "of", "the", "authenticated", "entity", "if", "any", "." ]

[ "func", "DescribeFacades", "(", "registry", "*", "facade", ".", "Registry", ")", "[", "]", "params", ".", "FacadeVersions", "{", "facades", ":=", "registry", ".", "List", "(", ")", "\n", "result", ":=", "make", "(", "[", "]", "params", ".", "FacadeVersions", ",", "len", "(", "facades", ")", ")", "\n", "for", "i", ",", "f", ":=", "range", "facades", "{", "result", "[", "i", "]", ".", "Name", "=", "f", ".", "Name", "\n", "result", "[", "i", "]", ".", "Versions", "=", "f", ".", "Versions", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "DescribeFacades", "returns", "the", "list", "of", "available", "Facades", "and", "their", "Versions" ]

[ "func", "guiAddr", "(", "conn", "api", ".", "Connection", ")", "string", "{", "if", "dnsName", ":=", "conn", ".", "PublicDNSName", "(", ")", ";", "dnsName", "!=", "\"", "\"", "{", "return", "dnsName", "\n", "}", "\n", "return", "conn", ".", "Addr", "(", ")", "\n", "}" ]

[ "guiAddr", "returns", "an", "address", "where", "the", "GUI", "is", "available", "." ]

[ "func", "(", "c", "*", "guiCommand", ")", "checkAvailable", "(", "rawURL", ",", "newRawURL", "string", ",", "conn", "api", ".", "Connection", ")", "(", "string", ",", "error", ")", "{", "client", ",", "err", ":=", "conn", ".", "HTTPClient", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "=", "clientGet", "(", "client", ",", "newRawURL", ")", ";", "err", "==", "nil", "{", "return", "newRawURL", ",", "nil", "\n", "}", "\n", "if", "err", "=", "clientGet", "(", "client", ",", "rawURL", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "rawURL", ",", "nil", "\n", "}" ]

[ "checkAvailable", "ensures", "the", "Juju", "GUI", "is", "available", "on", "the", "controller", "at", "one", "of", "the", "given", "URLs", "returning", "the", "successful", "URL", "." ]

[ "func", "(", "c", "*", "guiCommand", ")", "openBrowser", "(", "ctx", "*", "cmd", ".", "Context", ",", "rawURL", "string", ",", "vers", "*", "version", ".", "Number", ")", "error", "{", "u", ",", "err", ":=", "url", ".", "Parse", "(", "rawURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "noBrowser", "&&", "!", "c", ".", "browser", "{", "versInfo", ":=", "\"", "\"", "\n", "if", "vers", "!=", "nil", "{", "versInfo", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "vers", ")", "\n", "}", "\n", "modelName", ",", "err", ":=", "c", ".", "ModelName", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ctx", ".", "Infof", "(", "\"", "\\n", "\"", ",", "versInfo", ",", "modelName", ",", "u", ".", "String", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n", "err", "=", "webbrowserOpen", "(", "u", ")", "\n", "if", "err", "==", "nil", "{", "ctx", ".", "Infof", "(", "\"", "\"", ")", "\n", "ctx", ".", "Infof", "(", "\"", "\\n", "\"", ",", "u", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "err", "==", "webbrowser", ".", "ErrNoBrowser", "{", "ctx", ".", "Infof", "(", "\"", "\\n", "\"", ",", "u", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}" ]

[ "openBrowser", "opens", "the", "Juju", "GUI", "at", "the", "given", "URL", "." ]

[ "func", "(", "c", "*", "guiCommand", ")", "showCredentials", "(", "ctx", "*", "cmd", ".", "Context", ")", "error", "{", "if", "c", ".", "hideCreds", "||", "!", "c", ".", "showCreds", "{", "return", "nil", "\n", "}", "\n", "// TODO(wallyworld) - what to do if we are using a macaroon.", "accountDetails", ",", "err", ":=", "c", ".", "CurrentAccountDetails", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "password", ":=", "accountDetails", ".", "Password", "\n", "if", "password", "==", "\"", "\"", "{", "// TODO(wallyworld) - fix this", "password", "=", "\"", "\"", "\n", "}", "\n", "ctx", ".", "Infof", "(", "\"", "\\n", "\\n", "\"", ",", "accountDetails", ".", "User", ",", "password", ")", "\n", "return", "nil", "\n", "}" ]

[ "showCredentials", "shows", "the", "admin", "username", "and", "password", "." ]

[ "func", "volumeAttachmentDevicePath", "(", "volumeInfo", "state", ".", "VolumeInfo", ",", "volumeAttachmentInfo", "state", ".", "VolumeAttachmentInfo", ",", "blockDevice", "state", ".", "BlockDeviceInfo", ",", ")", "(", "string", ",", "error", ")", "{", "if", "volumeInfo", ".", "HardwareId", "!=", "\"", "\"", "||", "volumeInfo", ".", "WWN", "!=", "\"", "\"", "||", "volumeAttachmentInfo", ".", "DeviceName", "!=", "\"", "\"", "||", "volumeAttachmentInfo", ".", "DeviceLink", "!=", "\"", "\"", "{", "// Prefer the volume attachment's information over what is", "// in the published block device information, but only if the", "// block device information actually has any device links. In", "// some cases, the block device has very little hw info published.", "var", "deviceLinks", "[", "]", "string", "\n", "if", "volumeAttachmentInfo", ".", "DeviceLink", "!=", "\"", "\"", "&&", "len", "(", "blockDevice", ".", "DeviceLinks", ")", ">", "0", "{", "deviceLinks", "=", "[", "]", "string", "{", "volumeAttachmentInfo", ".", "DeviceLink", "}", "\n", "}", "\n", "var", "deviceName", "string", "\n", "if", "blockDevice", ".", "DeviceName", "!=", "\"", "\"", "{", "deviceName", "=", "blockDevice", ".", "DeviceName", "\n", "}", "else", "{", "deviceName", "=", "volumeAttachmentInfo", ".", "DeviceName", "\n", "}", "\n", "return", "storage", ".", "BlockDevicePath", "(", "storage", ".", "BlockDevice", "{", "HardwareId", ":", "volumeInfo", ".", "HardwareId", ",", "WWN", ":", "volumeInfo", ".", "WWN", ",", "DeviceName", ":", "deviceName", ",", "DeviceLinks", ":", "deviceLinks", ",", "}", ")", "\n", "}", "\n", "return", "storage", ".", "BlockDevicePath", "(", "BlockDeviceFromState", "(", "blockDevice", ")", ")", "\n", "}" ]

[ "volumeAttachmentDevicePath", "returns", "the", "absolute", "device", "path", "for", "a", "volume", "attachment", ".", "The", "value", "is", "only", "meaningful", "in", "the", "context", "of", "the", "machine", "that", "the", "volume", "is", "attached", "to", "." ]

[ "func", "StorageTags", "(", "storageInstance", "state", ".", "StorageInstance", ",", "modelUUID", ",", "controllerUUID", "string", ",", "tagger", "tags", ".", "ResourceTagger", ",", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "storageTags", ":=", "tags", ".", "ResourceTags", "(", "names", ".", "NewModelTag", "(", "modelUUID", ")", ",", "names", ".", "NewControllerTag", "(", "controllerUUID", ")", ",", "tagger", ",", ")", "\n", "if", "storageInstance", "!=", "nil", "{", "storageTags", "[", "tags", ".", "JujuStorageInstance", "]", "=", "storageInstance", ".", "Tag", "(", ")", ".", "Id", "(", ")", "\n", "if", "owner", ",", "ok", ":=", "storageInstance", ".", "Owner", "(", ")", ";", "ok", "{", "storageTags", "[", "tags", ".", "JujuStorageOwner", "]", "=", "owner", ".", "Id", "(", ")", "\n", "}", "\n", "}", "\n", "return", "storageTags", ",", "nil", "\n", "}" ]

[ "StorageTags", "returns", "the", "tags", "that", "should", "be", "set", "on", "a", "volume", "or", "filesystem", "if", "the", "provider", "supports", "them", "." ]

[ "func", "ClassifyDetachedStorage", "(", "stVolume", "VolumeAccess", ",", "stFile", "FilesystemAccess", ",", "storage", "[", "]", "state", ".", "StorageInstance", ",", ")", "(", "destroyed", ",", "detached", "[", "]", "params", ".", "Entity", ",", "_", "error", ")", "{", "for", "_", ",", "storage", ":=", "range", "storage", "{", "var", "detachable", "bool", "\n", "switch", "storage", ".", "Kind", "(", ")", "{", "case", "state", ".", "StorageKindFilesystem", ":", "if", "stFile", "==", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "NotImplementedf", "(", "\"", "\"", ")", "\n", "}", "\n", "f", ",", "err", ":=", "stFile", ".", "StorageInstanceFilesystem", "(", "storage", ".", "StorageTag", "(", ")", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "detachable", "=", "f", ".", "Detachable", "(", ")", "\n", "case", "state", ".", "StorageKindBlock", ":", "if", "stVolume", "==", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "NotImplementedf", "(", "\"", "\"", ")", "\n", "}", "\n", "v", ",", "err", ":=", "stVolume", ".", "StorageInstanceVolume", "(", "storage", ".", "StorageTag", "(", ")", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "detachable", "=", "v", ".", "Detachable", "(", ")", "\n", "default", ":", "return", "nil", ",", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "storage", ".", "Kind", "(", ")", ")", "\n", "}", "\n", "entity", ":=", "params", ".", "Entity", "{", "storage", ".", "StorageTag", "(", ")", ".", "String", "(", ")", "}", "\n", "if", "detachable", "{", "detached", "=", "append", "(", "detached", ",", "entity", ")", "\n", "}", "else", "{", "destroyed", "=", "append", "(", "destroyed", ",", "entity", ")", "\n", "}", "\n", "}", "\n", "return", "destroyed", ",", "detached", ",", "nil", "\n", "}" ]

[ "ClassifyDetachedStorage", "classifies", "storage", "instances", "into", "those", "that", "will", "be", "destroyed", "and", "those", "that", "will", "be", "detached", "when", "their", "attachment", "is", "removed", ".", "Any", "storage", "that", "is", "not", "found", "will", "be", "omitted", "." ]

[ "func", "NewListControllersCommand", "(", ")", "cmd", ".", "Command", "{", "cmd", ":=", "&", "listControllersCommand", "{", "store", ":", "jujuclient", ".", "NewFileClientStore", "(", ")", ",", "}", "\n", "return", "modelcmd", ".", "WrapBase", "(", "cmd", ")", "\n", "}" ]

[ "NewListControllersCommand", "returns", "a", "command", "to", "list", "registered", "controllers", "." ]

[ "func", "NewStringsWorker", "(", "handler", "StringsWatchHandler", ")", "worker", ".", "Worker", "{", "sw", ":=", "&", "stringsWorker", "{", "handler", ":", "handler", ",", "}", "\n", "sw", ".", "tomb", ".", "Go", "(", "sw", ".", "loop", ")", "\n", "return", "sw", "\n", "}" ]

[ "NewStringsWorker", "starts", "a", "new", "worker", "running", "the", "business", "logic", "from", "the", "handler", ".", "The", "worker", "loop", "is", "started", "in", "another", "goroutine", "as", "a", "side", "effect", "of", "calling", "this", "." ]

[ "func", "(", "i", "sigmaInstance", ")", "Id", "(", ")", "instance", ".", "Id", "{", "id", ":=", "instance", ".", "Id", "(", "i", ".", "server", ".", "UUID", "(", ")", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "id", ")", "\n", "return", "id", "\n", "}" ]

[ "Id", "returns", "a", "provider", "-", "generated", "identifier", "for", "the", "Instance", "." ]

[ "func", "(", "i", "sigmaInstance", ")", "Status", "(", "ctx", "context", ".", "ProviderCallContext", ")", "instance", ".", "Status", "{", "entityStatus", ":=", "i", ".", "server", ".", "Status", "(", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "entityStatus", ")", "\n", "jujuStatus", ":=", "status", ".", "Pending", "\n", "switch", "entityStatus", "{", "case", "gosigma", ".", "ServerStarting", ":", "jujuStatus", "=", "status", ".", "Allocating", "\n", "case", "gosigma", ".", "ServerRunning", ":", "jujuStatus", "=", "status", ".", "Running", "\n", "case", "gosigma", ".", "ServerStopping", ",", "gosigma", ".", "ServerStopped", ":", "jujuStatus", "=", "status", ".", "Empty", "\n", "case", "gosigma", ".", "ServerUnavailable", ":", "// I am not sure about this one.", "jujuStatus", "=", "status", ".", "Pending", "\n", "default", ":", "jujuStatus", "=", "status", ".", "Pending", "\n", "}", "\n\n", "return", "instance", ".", "Status", "{", "Status", ":", "jujuStatus", ",", "Message", ":", "entityStatus", ",", "}", "\n\n", "}" ]

[ "Status", "returns", "the", "provider", "-", "specific", "status", "for", "the", "instance", "." ]

[ "func", "(", "i", "sigmaInstance", ")", "Addresses", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "network", ".", "Address", ",", "error", ")", "{", "ip", ":=", "i", ".", "findIPv4", "(", ")", "\n\n", "if", "ip", "!=", "\"", "\"", "{", "addr", ":=", "network", ".", "Address", "{", "Value", ":", "ip", ",", "Type", ":", "network", ".", "IPv4Address", ",", "Scope", ":", "network", ".", "ScopePublic", ",", "}", "\n\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "addr", ")", "\n\n", "return", "[", "]", "network", ".", "Address", "{", "addr", "}", ",", "nil", "\n", "}", "\n", "return", "[", "]", "network", ".", "Address", "{", "}", ",", "nil", "\n", "}" ]

[ "Addresses", "returns", "a", "list", "of", "hostnames", "or", "ip", "addresses", "associated", "with", "the", "instance", ".", "This", "will", "supercede", "DNSName", "which", "can", "be", "implemented", "by", "selecting", "a", "preferred", "address", "." ]

[ "func", "(", "i", "sigmaInstance", ")", "OpenPorts", "(", "ctx", "context", ".", "ProviderCallContext", ",", "machineID", "string", ",", "ports", "[", "]", "network", ".", "IngressRule", ")", "error", "{", "return", "errors", ".", "NotImplementedf", "(", "\"", "\"", ")", "\n", "}" ]

[ "OpenPorts", "opens", "the", "given", "ports", "on", "the", "instance", "which", "should", "have", "been", "started", "with", "the", "given", "machine", "id", "." ]

[ "func", "(", "i", "sigmaInstance", ")", "IngressRules", "(", "ctx", "context", ".", "ProviderCallContext", ",", "machineID", "string", ")", "(", "[", "]", "network", ".", "IngressRule", ",", "error", ")", "{", "return", "nil", ",", "errors", ".", "NotImplementedf", "(", "\"", "\"", ")", "\n", "}" ]

[ "IngressRules", "returns", "the", "set", "of", "ports", "open", "on", "the", "instance", "which", "should", "have", "been", "started", "with", "the", "given", "machine", "id", ".", "The", "rules", "are", "returned", "as", "sorted", "by", "SortInstanceRules", "." ]

[ "func", "IsValidAddressConfigMethod", "(", "value", "string", ")", "bool", "{", "switch", "AddressConfigMethod", "(", "value", ")", "{", "case", "LoopbackAddress", ",", "StaticAddress", ",", "DynamicAddress", ",", "ManualAddress", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsValidAddressConfigMethod", "returns", "whether", "the", "given", "value", "is", "a", "valid", "method", "to", "configure", "a", "link", "-", "layer", "network", "device", "s", "IP", "address", "." ]

[ "func", "(", "addr", "*", "Address", ")", "DocID", "(", ")", "string", "{", "return", "addr", ".", "st", ".", "docID", "(", "addr", ".", "doc", ".", "DocID", ")", "\n", "}" ]

[ "DocID", "returns", "the", "globally", "unique", "ID", "of", "the", "IP", "address", "including", "the", "model", "UUID", "as", "prefix", "." ]

[ "func", "(", "addr", "*", "Address", ")", "ProviderID", "(", ")", "network", ".", "Id", "{", "return", "network", ".", "Id", "(", "addr", ".", "doc", ".", "ProviderID", ")", "\n", "}" ]

[ "ProviderID", "returns", "the", "provider", "-", "specific", "IP", "address", "ID", "if", "set", "." ]

[ "func", "(", "addr", "*", "Address", ")", "Machine", "(", ")", "(", "*", "Machine", ",", "error", ")", "{", "return", "addr", ".", "st", ".", "Machine", "(", "addr", ".", "doc", ".", "MachineID", ")", "\n", "}" ]

[ "Machine", "returns", "the", "Machine", "this", "IP", "address", "belongs", "to", "." ]

[ "func", "(", "addr", "*", "Address", ")", "Device", "(", ")", "(", "*", "LinkLayerDevice", ",", "error", ")", "{", "return", "addr", ".", "machineProxy", "(", ")", ".", "LinkLayerDevice", "(", "addr", ".", "doc", ".", "DeviceName", ")", "\n", "}" ]

[ "Device", "returns", "the", "LinkLayeyDevice", "this", "IP", "address", "is", "assigned", "to", "." ]

[ "func", "(", "addr", "*", "Address", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "addr", ".", "doc", ".", "ConfigMethod", ",", "addr", ".", "doc", ".", "Value", ",", "addr", ".", "doc", ".", "DeviceName", ",", "addr", ".", "doc", ".", "MachineID", ",", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "the", "IP", "address", "." ]

[ "func", "(", "addr", "*", "Address", ")", "Remove", "(", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "addr", ")", "\n\n", "removeOp", ":=", "removeIPAddressDocOp", "(", "addr", ".", "doc", ".", "DocID", ")", "\n", "ops", ":=", "[", "]", "txn", ".", "Op", "{", "removeOp", "}", "\n", "if", "addr", ".", "ProviderID", "(", ")", "!=", "\"", "\"", "{", "op", ":=", "addr", ".", "st", ".", "networkEntityGlobalKeyRemoveOp", "(", "\"", "\"", ",", "addr", ".", "ProviderID", "(", ")", ")", "\n", "ops", "=", "append", "(", "ops", ",", "op", ")", "\n", "}", "\n", "return", "addr", ".", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", "\n", "}" ]

[ "Remove", "removes", "the", "IP", "address", "if", "it", "exists", ".", "No", "error", "is", "returned", "when", "the", "address", "was", "already", "removed", "." ]

[ "func", "removeIPAddressDocOp", "(", "ipAddressDocID", "string", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "ipAddressesC", ",", "Id", ":", "ipAddressDocID", ",", "Remove", ":", "true", ",", "}", "\n", "}" ]

[ "removeIPAddressDocOpOp", "returns", "an", "operation", "to", "remove", "the", "ipAddressDoc", "matching", "the", "given", "ipAddressDocID", "without", "asserting", "it", "still", "exists", "." ]

[ "func", "insertIPAddressDocOp", "(", "newDoc", "*", "ipAddressDoc", ")", "txn", ".", "Op", "{", "return", "txn", ".", "Op", "{", "C", ":", "ipAddressesC", ",", "Id", ":", "newDoc", ".", "DocID", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "*", "newDoc", ",", "}", "\n", "}" ]

[ "insertIPAddressDocOp", "returns", "an", "operation", "inserting", "the", "given", "newDoc", "asserting", "it", "does", "not", "exist", "yet", "." ]

[ "func", "updateIPAddressDocOp", "(", "existingDoc", ",", "newDoc", "*", "ipAddressDoc", ")", "(", "txn", ".", "Op", ",", "bool", ")", "{", "changes", ":=", "make", "(", "bson", ".", "M", ")", "\n", "deletes", ":=", "make", "(", "bson", ".", "M", ")", "\n", "if", "existingDoc", ".", "ProviderID", "==", "\"", "\"", "&&", "newDoc", ".", "ProviderID", "!=", "\"", "\"", "{", "// Only allow changing the ProviderID if it was empty.", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "ProviderID", "\n", "}", "\n", "if", "existingDoc", ".", "ConfigMethod", "!=", "newDoc", ".", "ConfigMethod", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "ConfigMethod", "\n", "}", "\n\n", "if", "existingDoc", ".", "SubnetCIDR", "!=", "newDoc", ".", "SubnetCIDR", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "SubnetCIDR", "\n", "}", "\n\n", "if", "strsDiffer", "(", "newDoc", ".", "DNSServers", ",", "existingDoc", ".", "DNSServers", ")", "{", "if", "len", "(", "newDoc", ".", "DNSServers", ")", "==", "0", "{", "deletes", "[", "\"", "\"", "]", "=", "1", "\n", "}", "else", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "DNSServers", "\n", "}", "\n", "}", "\n", "if", "strsDiffer", "(", "newDoc", ".", "DNSSearchDomains", ",", "existingDoc", ".", "DNSSearchDomains", ")", "{", "if", "len", "(", "newDoc", ".", "DNSSearchDomains", ")", "==", "0", "{", "deletes", "[", "\"", "\"", "]", "=", "1", "\n", "}", "else", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "DNSSearchDomains", "\n", "}", "\n", "}", "\n\n", "if", "existingDoc", ".", "GatewayAddress", "!=", "newDoc", ".", "GatewayAddress", "{", "changes", "[", "\"", "\"", "]", "=", "newDoc", ".", "GatewayAddress", "\n", "}", "\n\n", "var", "updates", "bson", ".", "D", "\n", "if", "len", "(", "changes", ")", ">", "0", "{", "updates", "=", "append", "(", "updates", ",", "bson", ".", "DocElem", "{", "Name", ":", "\"", "\"", ",", "Value", ":", "changes", "}", ")", "\n", "}", "\n", "if", "len", "(", "deletes", ")", ">", "0", "{", "updates", "=", "append", "(", "updates", ",", "bson", ".", "DocElem", "{", "Name", ":", "\"", "\"", ",", "Value", ":", "deletes", "}", ")", "\n", "}", "\n\n", "return", "txn", ".", "Op", "{", "C", ":", "ipAddressesC", ",", "Id", ":", "existingDoc", ".", "DocID", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Update", ":", "updates", ",", "}", ",", "len", "(", "updates", ")", ">", "0", "\n", "}" ]

[ "updateIPAddressDocOp", "returns", "an", "operation", "updating", "the", "fields", "of", "existingDoc", "with", "the", "respective", "values", "of", "those", "fields", "in", "newDoc", ".", "DocID", "ModelUUID", "Value", "MachineID", "and", "DeviceName", "cannot", "be", "changed", ".", "ProviderID", "cannot", "be", "changed", "once", "set", ".", "DNSServers", "and", "DNSSearchDomains", "are", "deleted", "when", "nil", ".", "In", "all", "other", "cases", "newDoc", "values", "overwrites", "existingDoc", "values", "." ]

[ "func", "(", "st", "*", "State", ")", "AllIPAddresses", "(", ")", "(", "addresses", "[", "]", "*", "Address", ",", "err", "error", ")", "{", "addressesCollection", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "ipAddressesC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "sdocs", ":=", "[", "]", "ipAddressDoc", "{", "}", "\n", "err", "=", "addressesCollection", ".", "Find", "(", "bson", ".", "D", "{", "}", ")", ".", "All", "(", "&", "sdocs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "a", ":=", "range", "sdocs", "{", "addresses", "=", "append", "(", "addresses", ",", "newIPAddress", "(", "st", ",", "a", ")", ")", "\n", "}", "\n", "return", "addresses", ",", "nil", "\n", "}" ]

[ "AllIPAddresses", "returns", "all", "ip", "addresses", "in", "the", "model", "." ]

[ "func", "defaultReachableChecker", "(", ")", "jujussh", ".", "ReachableChecker", "{", "return", "jujussh", ".", "NewReachableChecker", "(", "&", "net", ".", "Dialer", "{", "Timeout", ":", "SSHRetryDelay", "}", ",", "SSHTimeout", ")", "\n", "}" ]

[ "defaultReachableChecker", "returns", "a", "jujussh", ".", "ReachableChecker", "with", "a", "connection", "timeout", "of", "SSHRetryDelay", "and", "an", "overall", "timout", "of", "SSHTimeout" ]

[ "func", "(", "c", "*", "SSHCommon", ")", "initRun", "(", ")", "error", "{", "if", "err", ":=", "c", ".", "ensureAPIClient", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "if", "proxy", ",", "err", ":=", "c", ".", "proxySSH", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "else", "{", "c", ".", "proxy", "=", "proxy", "\n", "}", "\n\n", "// Used mostly for testing, but useful for debugging and/or", "// backwards-compatibility with some scripts.", "c", ".", "forceAPIv1", "=", "os", ".", "Getenv", "(", "jujuSSHClientForceAPIv1", ")", "!=", "\"", "\"", "\n", "return", "nil", "\n", "}" ]

[ "initRun", "initializes", "the", "API", "connection", "if", "required", "and", "determines", "if", "SSH", "proxying", "is", "required", ".", "It", "must", "be", "called", "at", "the", "top", "of", "the", "command", "s", "Run", "method", ".", "The", "apiClient", "apiAddr", "and", "proxy", "fields", "are", "initialized", "after", "this", "call", "." ]

[ "func", "(", "c", "*", "SSHCommon", ")", "getSSHOptions", "(", "enablePty", "bool", ",", "targets", "...", "*", "resolvedTarget", ")", "(", "*", "ssh", ".", "Options", ",", "error", ")", "{", "var", "options", "ssh", ".", "Options", "\n\n", "if", "c", ".", "noHostKeyChecks", "{", "options", ".", "SetStrictHostKeyChecking", "(", "ssh", ".", "StrictHostChecksNo", ")", "\n", "options", ".", "SetKnownHostsFile", "(", "os", ".", "DevNull", ")", "\n", "}", "else", "{", "knownHostsPath", ",", "err", ":=", "c", ".", "generateKnownHosts", "(", "targets", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// There might not be a custom known_hosts file if the SSH", "// targets are specified using arbitrary hostnames or", "// addresses. In this case, the user's personal known_hosts", "// file is used.", "if", "knownHostsPath", "!=", "\"", "\"", "{", "// When a known_hosts file has been generated, enforce", "// strict host key checking.", "options", ".", "SetStrictHostKeyChecking", "(", "ssh", ".", "StrictHostChecksYes", ")", "\n", "options", ".", "SetKnownHostsFile", "(", "knownHostsPath", ")", "\n", "}", "\n", "}", "\n\n", "if", "enablePty", "{", "options", ".", "EnablePTY", "(", ")", "\n", "}", "\n\n", "if", "c", ".", "proxy", "{", "if", "err", ":=", "c", ".", "setProxyCommand", "(", "&", "options", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "&", "options", ",", "nil", "\n", "}" ]

[ "getSSHOptions", "configures", "SSH", "options", "based", "on", "command", "line", "arguments", "and", "the", "SSH", "targets", "specified", "." ]

[ "func", "(", "c", "*", "SSHCommon", ")", "generateKnownHosts", "(", "targets", "[", "]", "*", "resolvedTarget", ")", "(", "string", ",", "error", ")", "{", "knownHosts", ":=", "newKnownHostsBuilder", "(", ")", "\n", "agentCount", ":=", "0", "\n", "nonAgentCount", ":=", "0", "\n", "for", "_", ",", "target", ":=", "range", "targets", "{", "if", "target", ".", "isAgent", "(", ")", "{", "agentCount", "++", "\n", "keys", ",", "err", ":=", "c", ".", "apiClient", ".", "PublicKeys", "(", "target", ".", "entity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "target", ".", "entity", ")", "\n", "}", "\n", "knownHosts", ".", "add", "(", "target", ".", "host", ",", "keys", ")", "\n", "}", "else", "{", "nonAgentCount", "++", "\n", "}", "\n", "}", "\n\n", "if", "agentCount", ">", "0", "&&", "nonAgentCount", ">", "0", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "knownHosts", ".", "size", "(", ")", "==", "0", "{", "// No public keys to write so exit early.", "return", "\"", "\"", ",", "nil", "\n", "}", "\n\n", "f", ",", "err", ":=", "ioutil", ".", "TempFile", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "c", ".", "knownHostsPath", "=", "f", ".", "Name", "(", ")", "// Record for later deletion", "\n", "if", "knownHosts", ".", "write", "(", "f", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "c", ".", "knownHostsPath", ",", "nil", "\n", "}" ]

[ "generateKnownHosts", "takes", "the", "provided", "targets", "retrieves", "the", "SSH", "public", "host", "keys", "for", "them", "and", "generates", "a", "temporary", "known_hosts", "file", "for", "them", "." ]

[ "func", "(", "c", "*", "SSHCommon", ")", "setProxyCommand", "(", "options", "*", "ssh", ".", "Options", ")", "error", "{", "apiServerHost", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "c", ".", "apiAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "juju", ",", "err", ":=", "getJujuExecutable", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "modelName", ",", "err", ":=", "c", ".", "ModelName", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// TODO(mjs) 2016-05-09 LP #1579592 - It would be good to check the", "// host key of the controller machine being used for proxying", "// here. This isn't too serious as all traffic passing through the", "// controller host is encrypted and the host key of the ultimate", "// target host is verified but it would still be better to perform", "// this extra level of checking.", "options", ".", "SetProxyCommand", "(", "juju", ",", "\"", "\"", ",", "\"", "\"", "+", "modelName", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "+", "apiServerHost", ",", "\"", "\"", ",", "\"", "\"", ",", ")", "\n", "return", "nil", "\n", "}" ]

[ "setProxyCommand", "sets", "the", "proxy", "command", "option", "." ]

[ "func", "(", "c", "*", "SSHCommon", ")", "initAPIClient", "(", ")", "error", "{", "conn", ",", "err", ":=", "c", ".", "NewAPIRoot", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "c", ".", "apiClient", "=", "sshclient", ".", "NewFacade", "(", "conn", ")", "\n", "c", ".", "apiAddr", "=", "conn", ".", "Addr", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "initAPIClient", "initialises", "the", "API", "connection", "." ]

[ "func", "(", "c", "*", "SSHCommon", ")", "reachableAddressGetter", "(", "entity", "string", ")", "(", "string", ",", "error", ")", "{", "addresses", ",", "err", ":=", "c", ".", "apiClient", ".", "AllAddresses", "(", "entity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "else", "if", "len", "(", "addresses", ")", "==", "0", "{", "return", "\"", "\"", ",", "network", ".", "NoAddressError", "(", "\"", "\"", ")", "\n", "}", "else", "if", "len", "(", "addresses", ")", "==", "1", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "addresses", "[", "0", "]", ")", "\n", "return", "addresses", "[", "0", "]", ",", "nil", "\n", "}", "\n", "publicKeys", ":=", "[", "]", "string", "{", "}", "\n", "if", "!", "c", ".", "noHostKeyChecks", "{", "publicKeys", ",", "err", "=", "c", ".", "apiClient", ".", "PublicKeys", "(", "entity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "entity", ")", "\n", "}", "\n", "}", "\n\n", "hostPorts", ":=", "network", ".", "NewHostPorts", "(", "SSHPort", ",", "addresses", "...", ")", "\n", "usableHPs", ":=", "network", ".", "FilterUnusableHostPorts", "(", "hostPorts", ")", "\n", "bestHP", ",", "err", ":=", "c", ".", "hostChecker", ".", "FindHost", "(", "usableHPs", ",", "publicKeys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "bestHP", ".", "Address", ".", "Value", ",", "nil", "\n", "}" ]

[ "reachableAddressGetter", "dials", "all", "addresses", "of", "the", "given", "entity", "returning", "the", "first", "one", "that", "succeeds", ".", "Only", "used", "with", "SSHClient", "API", "facade", "v2", "or", "later", "is", "available", ".", "It", "does", "not", "try", "to", "dial", "if", "only", "one", "address", "is", "available", "." ]

[ "func", "NewVersionedToolsConstraint", "(", "vers", "version", ".", "Number", ",", "params", "simplestreams", ".", "LookupParams", ")", "*", "ToolsConstraint", "{", "return", "&", "ToolsConstraint", "{", "LookupParams", ":", "params", ",", "Version", ":", "vers", "}", "\n", "}" ]

[ "NewVersionedToolsConstraint", "returns", "a", "ToolsConstraint", "for", "a", "tools", "with", "a", "specific", "version", "." ]

[ "func", "(", "t", "*", "ToolsMetadata", ")", "sortString", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "t", ".", "Version", ",", "t", ".", "Release", ",", "t", ".", "Arch", ")", "\n", "}" ]

[ "sortString", "is", "used", "by", "byVersion", "to", "sort", "a", "list", "of", "ToolsMetadata", "." ]

[ "func", "(", "t", "*", "ToolsMetadata", ")", "binary", "(", ")", "(", "version", ".", "Binary", ",", "error", ")", "{", "num", ",", "err", ":=", "version", ".", "Parse", "(", "t", ".", "Version", ")", "\n", "if", "err", "!=", "nil", "{", "return", "version", ".", "Binary", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "version", ".", "Binary", "{", "Number", ":", "num", ",", "Series", ":", "t", ".", "Release", ",", "Arch", ":", "t", ".", "Arch", ",", "}", ",", "nil", "\n", "}" ]

[ "binary", "returns", "the", "tools", "metadata", "s", "binary", "version", "which", "may", "be", "used", "for", "map", "lookup", "." ]

[ "func", "Fetch", "(", "sources", "[", "]", "simplestreams", ".", "DataSource", ",", "cons", "*", "ToolsConstraint", ",", ")", "(", "[", "]", "*", "ToolsMetadata", ",", "*", "simplestreams", ".", "ResolveInfo", ",", "error", ")", "{", "params", ":=", "simplestreams", ".", "GetMetadataParams", "{", "StreamsVersion", ":", "currentStreamsVersion", ",", "LookupConstraint", ":", "cons", ",", "ValueParams", ":", "simplestreams", ".", "ValueParams", "{", "DataType", ":", "ContentDownload", ",", "FilterFunc", ":", "appendMatchingTools", ",", "MirrorContentId", ":", "ToolsContentId", "(", "cons", ".", "Stream", ")", ",", "ValueTemplate", ":", "ToolsMetadata", "{", "}", ",", "}", ",", "}", "\n", "items", ",", "resolveInfo", ",", "err", ":=", "simplestreams", ".", "GetMetadata", "(", "sources", ",", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "metadata", ":=", "make", "(", "[", "]", "*", "ToolsMetadata", ",", "len", "(", "items", ")", ")", "\n", "for", "i", ",", "md", ":=", "range", "items", "{", "metadata", "[", "i", "]", "=", "md", ".", "(", "*", "ToolsMetadata", ")", "\n", "}", "\n", "// Sorting the metadata is not strictly necessary, but it ensures consistent ordering for", "// all compilers, and it just makes it easier to look at the data.", "Sort", "(", "metadata", ")", "\n", "return", "metadata", ",", "resolveInfo", ",", "nil", "\n", "}" ]

[ "Fetch", "returns", "a", "list", "of", "tools", "for", "the", "specified", "cloud", "matching", "the", "constraint", ".", "The", "base", "URL", "locations", "are", "as", "specified", "-", "the", "first", "location", "which", "has", "a", "file", "is", "the", "one", "used", ".", "Signed", "data", "is", "preferred", "but", "if", "there", "is", "no", "signed", "data", "available", "and", "onlySigned", "is", "false", "then", "unsigned", "data", "is", "used", "." ]

[ "func", "appendMatchingTools", "(", "source", "simplestreams", ".", "DataSource", ",", "matchingTools", "[", "]", "interface", "{", "}", ",", "tools", "map", "[", "string", "]", "interface", "{", "}", ",", "cons", "simplestreams", ".", "LookupConstraint", ")", "(", "[", "]", "interface", "{", "}", ",", "error", ")", "{", "toolsMap", ":=", "make", "(", "map", "[", "version", ".", "Binary", "]", "*", "ToolsMetadata", ",", "len", "(", "matchingTools", ")", ")", "\n", "for", "_", ",", "val", ":=", "range", "matchingTools", "{", "tm", ":=", "val", ".", "(", "*", "ToolsMetadata", ")", "\n", "binary", ",", "err", ":=", "tm", ".", "binary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "toolsMap", "[", "binary", "]", "=", "tm", "\n", "}", "\n", "for", "_", ",", "val", ":=", "range", "tools", "{", "tm", ":=", "val", ".", "(", "*", "ToolsMetadata", ")", "\n", "if", "!", "set", ".", "NewStrings", "(", "cons", ".", "Params", "(", ")", ".", "Series", "...", ")", ".", "Contains", "(", "tm", ".", "Release", ")", "{", "continue", "\n", "}", "\n", "if", "toolsConstraint", ",", "ok", ":=", "cons", ".", "(", "*", "ToolsConstraint", ")", ";", "ok", "{", "tmNumber", ":=", "version", ".", "MustParse", "(", "tm", ".", "Version", ")", "\n", "if", "toolsConstraint", ".", "Version", "==", "version", ".", "Zero", "{", "if", "toolsConstraint", ".", "MajorVersion", ">=", "0", "&&", "toolsConstraint", ".", "MajorVersion", "!=", "tmNumber", ".", "Major", "{", "continue", "\n", "}", "\n", "if", "toolsConstraint", ".", "MinorVersion", ">=", "0", "&&", "toolsConstraint", ".", "MinorVersion", "!=", "tmNumber", ".", "Minor", "{", "continue", "\n", "}", "\n", "}", "else", "{", "if", "toolsConstraint", ".", "Version", "!=", "tmNumber", "{", "continue", "\n", "}", "\n", "}", "\n", "}", "\n", "binary", ",", "err", ":=", "tm", ".", "binary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "toolsMap", "[", "binary", "]", ";", "!", "ok", "{", "tm", ".", "FullPath", ",", "_", "=", "source", ".", "URL", "(", "tm", ".", "Path", ")", "\n", "matchingTools", "=", "append", "(", "matchingTools", ",", "tm", ")", "\n", "}", "\n", "}", "\n", "return", "matchingTools", ",", "nil", "\n", "}" ]

[ "appendMatchingTools", "updates", "matchingTools", "with", "tools", "metadata", "records", "from", "tools", "which", "belong", "to", "the", "specified", "series", ".", "If", "a", "tools", "record", "already", "exists", "in", "matchingTools", "it", "is", "not", "overwritten", "." ]

[ "func", "MetadataFromTools", "(", "toolsList", "coretools", ".", "List", ",", "toolsDir", "string", ")", "[", "]", "*", "ToolsMetadata", "{", "metadata", ":=", "make", "(", "[", "]", "*", "ToolsMetadata", ",", "len", "(", "toolsList", ")", ")", "\n", "for", "i", ",", "t", ":=", "range", "toolsList", "{", "path", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "toolsDir", ",", "t", ".", "Version", ".", "Number", ",", "t", ".", "Version", ".", "Series", ",", "t", ".", "Version", ".", "Arch", ")", "\n", "metadata", "[", "i", "]", "=", "&", "ToolsMetadata", "{", "Release", ":", "t", ".", "Version", ".", "Series", ",", "Version", ":", "t", ".", "Version", ".", "Number", ".", "String", "(", ")", ",", "Arch", ":", "t", ".", "Version", ".", "Arch", ",", "Path", ":", "path", ",", "FileType", ":", "\"", "\"", ",", "Size", ":", "t", ".", "Size", ",", "SHA256", ":", "t", ".", "SHA256", ",", "}", "\n", "}", "\n", "return", "metadata", "\n", "}" ]

[ "MetadataFromTools", "returns", "a", "tools", "metadata", "list", "derived", "from", "the", "given", "tools", "list", ".", "The", "size", "and", "sha256", "will", "not", "be", "computed", "if", "missing", "." ]

[ "func", "ResolveMetadata", "(", "stor", "storage", ".", "StorageReader", ",", "toolsDir", "string", ",", "metadata", "[", "]", "*", "ToolsMetadata", ")", "error", "{", "for", "_", ",", "md", ":=", "range", "metadata", "{", "if", "md", ".", "Size", "!=", "0", "{", "continue", "\n", "}", "\n", "binary", ",", "err", ":=", "md", ".", "binary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "logger", ".", "Infof", "(", "\"", "\"", ",", "toolsDir", ",", "binary", ")", "\n", "size", ",", "sha256hash", ",", "err", ":=", "fetchToolsHash", "(", "stor", ",", "toolsDir", ",", "binary", ")", "\n", "// Older versions of Juju only know about ppc64, not ppc64el,", "// so if there's no metadata for ppc64, dd metadata for that arch.", "if", "errors", ".", "IsNotFound", "(", "err", ")", "&&", "binary", ".", "Arch", "==", "arch", ".", "LEGACY_PPC64", "{", "ppc64elBinary", ":=", "binary", "\n", "ppc64elBinary", ".", "Arch", "=", "arch", ".", "PPC64EL", "\n", "md", ".", "Path", "=", "strings", ".", "Replace", "(", "md", ".", "Path", ",", "binary", ".", "Arch", ",", "ppc64elBinary", ".", "Arch", ",", "-", "1", ")", "\n", "size", ",", "sha256hash", ",", "err", "=", "fetchToolsHash", "(", "stor", ",", "toolsDir", ",", "ppc64elBinary", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "md", ".", "Size", "=", "size", "\n", "md", ".", "SHA256", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sha256hash", ".", "Sum", "(", "nil", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ResolveMetadata", "resolves", "incomplete", "metadata", "by", "fetching", "the", "tools", "from", "storage", "and", "computing", "the", "size", "and", "hash", "locally", "." ]

[ "func", "ReadMetadata", "(", "store", "storage", ".", "StorageReader", ",", "stream", "string", ")", "(", "[", "]", "*", "ToolsMetadata", ",", "error", ")", "{", "dataSource", ":=", "storage", ".", "NewStorageSimpleStreamsDataSource", "(", "\"", "\"", ",", "store", ",", "storage", ".", "BaseToolsPath", ",", "simplestreams", ".", "EXISTING_CLOUD_DATA", ",", "false", ")", "\n", "toolsConstraint", ",", "err", ":=", "makeToolsConstraint", "(", "simplestreams", ".", "CloudSpec", "{", "}", ",", "stream", ",", "-", "1", ",", "-", "1", ",", "coretools", ".", "Filter", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "metadata", ",", "_", ",", "err", ":=", "Fetch", "(", "[", "]", "simplestreams", ".", "DataSource", "{", "dataSource", "}", ",", "toolsConstraint", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "metadata", ",", "nil", "\n", "}" ]

[ "ReadMetadata", "returns", "the", "tools", "metadata", "from", "the", "given", "storage", "for", "the", "specified", "stream", "." ]

[ "func", "ReadAllMetadata", "(", "store", "storage", ".", "StorageReader", ")", "(", "map", "[", "string", "]", "[", "]", "*", "ToolsMetadata", ",", "error", ")", "{", "streamMetadata", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "*", "ToolsMetadata", ")", "\n", "for", "_", ",", "stream", ":=", "range", "AllMetadataStreams", "{", "metadata", ",", "err", ":=", "ReadMetadata", "(", "store", ",", "stream", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "metadata", ")", "==", "0", "{", "continue", "\n", "}", "\n", "streamMetadata", "[", "stream", "]", "=", "metadata", "\n", "}", "\n", "return", "streamMetadata", ",", "nil", "\n", "}" ]

[ "ReadAllMetadata", "returns", "the", "tools", "metadata", "from", "the", "given", "storage", "for", "all", "streams", ".", "The", "result", "is", "a", "map", "of", "metadata", "slices", "keyed", "on", "stream", "." ]

[ "func", "removeMetadataUpdated", "(", "metadataBytes", "[", "]", "byte", ")", "(", "string", ",", "error", ")", "{", "var", "metadata", "map", "[", "string", "]", "interface", "{", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "metadataBytes", ",", "&", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "delete", "(", "metadata", ",", "\"", "\"", ")", "\n\n", "metadataJson", ",", "err", ":=", "json", ".", "Marshal", "(", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "string", "(", "metadataJson", ")", ",", "nil", "\n", "}" ]

[ "removeMetadataUpdated", "unmarshalls", "simplestreams", "metadata", "clears", "the", "updated", "attribute", "and", "then", "marshalls", "back", "to", "a", "string", "." ]

[ "func", "metadataUnchanged", "(", "stor", "storage", ".", "Storage", ",", "stream", "string", ",", "generatedMetadata", "[", "]", "byte", ")", "(", "bool", ",", "error", ")", "{", "mdPath", ":=", "ProductMetadataPath", "(", "stream", ")", "\n", "filePath", ":=", "path", ".", "Join", "(", "storage", ".", "BaseToolsPath", ",", "mdPath", ")", "\n", "existingDataReader", ",", "err", ":=", "stor", ".", "Get", "(", "filePath", ")", "\n", "// If the file can't be retrieved, consider it has changed.", "if", "err", "!=", "nil", "{", "return", "false", ",", "nil", "\n", "}", "\n", "defer", "existingDataReader", ".", "Close", "(", ")", "\n", "existingData", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "existingDataReader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "// To do the comparison, we unmarshall the metadata, clear the", "// updated value, and marshall back to a string.", "existingMetadata", ",", "err", ":=", "removeMetadataUpdated", "(", "existingData", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "newMetadata", ",", "err", ":=", "removeMetadataUpdated", "(", "generatedMetadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "existingMetadata", "==", "newMetadata", ",", "nil", "\n", "}" ]

[ "metadataUnchanged", "returns", "true", "if", "the", "content", "of", "metadata", "for", "stream", "in", "stor", "is", "the", "same", "as", "generatedMetadata", "ignoring", "the", "updated", "attribute", "." ]

[ "func", "WriteMetadata", "(", "stor", "storage", ".", "Storage", ",", "streamMetadata", "map", "[", "string", "]", "[", "]", "*", "ToolsMetadata", ",", "streams", "[", "]", "string", ",", "writeMirrors", "ShouldWriteMirrors", ")", "error", "{", "// TODO(perrito666) 2016-05-02 lp:1558657", "updated", ":=", "time", ".", "Now", "(", ")", "\n", "index", ",", "legacyIndex", ",", "products", ",", "err", ":=", "MarshalToolsMetadataJSON", "(", "streamMetadata", ",", "updated", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "metadataInfo", ":=", "[", "]", "MetadataFile", "{", "{", "simplestreams", ".", "UnsignedIndex", "(", "currentStreamsVersion", ",", "IndexFileVersion", ")", ",", "index", "}", ",", "}", "\n", "if", "legacyIndex", "!=", "nil", "{", "metadataInfo", "=", "append", "(", "metadataInfo", ",", "MetadataFile", "{", "simplestreams", ".", "UnsignedIndex", "(", "currentStreamsVersion", ",", "1", ")", ",", "legacyIndex", ",", "}", ")", "\n", "}", "\n", "for", "_", ",", "stream", ":=", "range", "streams", "{", "if", "metadata", ",", "ok", ":=", "products", "[", "stream", "]", ";", "ok", "{", "// If metadata hasn't changed, do not overwrite.", "unchanged", ",", "err", ":=", "metadataUnchanged", "(", "stor", ",", "stream", ",", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "unchanged", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "stream", ")", "\n", "continue", "\n", "}", "\n", "// Metadata is different, so include it.", "metadataInfo", "=", "append", "(", "metadataInfo", ",", "MetadataFile", "{", "ProductMetadataPath", "(", "stream", ")", ",", "metadata", "}", ")", "\n", "}", "\n", "}", "\n", "if", "writeMirrors", "{", "streamsMirrorsMetadata", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "simplestreams", ".", "MirrorReference", ")", "\n", "for", "stream", ":=", "range", "streamMetadata", "{", "streamsMirrorsMetadata", "[", "ToolsContentId", "(", "stream", ")", "]", "=", "[", "]", "simplestreams", ".", "MirrorReference", "{", "{", "Updated", ":", "updated", ".", "Format", "(", "\"", "\"", ")", ",", "// YYYYMMDD", "DataType", ":", "ContentDownload", ",", "Format", ":", "simplestreams", ".", "MirrorFormat", ",", "Path", ":", "simplestreams", ".", "MirrorFile", ",", "}", "}", "\n", "}", "\n", "mirrorsMetadata", ":=", "map", "[", "string", "]", "map", "[", "string", "]", "[", "]", "simplestreams", ".", "MirrorReference", "{", "\"", "\"", ":", "streamsMirrorsMetadata", ",", "}", "\n", "mirrorsInfo", ",", "err", ":=", "json", ".", "MarshalIndent", "(", "&", "mirrorsMetadata", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "metadataInfo", "=", "append", "(", "metadataInfo", ",", "MetadataFile", "{", "simplestreams", ".", "UnsignedMirror", "(", "currentStreamsVersion", ")", ",", "mirrorsInfo", "}", ")", "\n", "}", "\n", "return", "writeMetadataFiles", "(", "stor", ",", "metadataInfo", ")", "\n", "}" ]

[ "WriteMetadata", "writes", "the", "given", "tools", "metadata", "for", "the", "specified", "streams", "to", "the", "given", "storage", ".", "streamMetadata", "contains", "all", "known", "metadata", "so", "that", "the", "correct", "index", "files", "can", "be", "written", ".", "Only", "product", "files", "for", "the", "specified", "streams", "are", "written", "." ]

[ "func", "fetchToolsHash", "(", "stor", "storage", ".", "StorageReader", ",", "stream", "string", ",", "ver", "version", ".", "Binary", ")", "(", "size", "int64", ",", "sha256hash", "hash", ".", "Hash", ",", "err", "error", ")", "{", "r", ",", "err", ":=", "storage", ".", "Get", "(", "stor", ",", "StorageName", "(", "ver", ",", "stream", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "nil", ",", "err", "\n", "}", "\n", "defer", "r", ".", "Close", "(", ")", "\n", "sha256hash", "=", "sha256", ".", "New", "(", ")", "\n", "size", ",", "err", "=", "io", ".", "Copy", "(", "sha256hash", ",", "r", ")", "\n", "return", "size", ",", "sha256hash", ",", "err", "\n", "}" ]

[ "fetchToolsHash", "fetches", "the", "tools", "from", "storage", "and", "calculates", "its", "size", "in", "bytes", "and", "computes", "a", "SHA256", "hash", "of", "its", "contents", "." ]

[ "func", "NewActionData", "(", "name", "string", ",", "tag", "*", "names", ".", "ActionTag", ",", "params", "map", "[", "string", "]", "interface", "{", "}", ")", "*", "ActionData", "{", "return", "&", "ActionData", "{", "Name", ":", "name", ",", "Tag", ":", "*", "tag", ",", "Params", ":", "params", ",", "ResultsMap", ":", "map", "[", "string", "]", "interface", "{", "}", "{", "}", ",", "}", "\n", "}" ]

[ "NewActionData", "builds", "a", "suitable", "ActionData", "struct", "with", "no", "nil", "members", ".", "this", "should", "only", "be", "called", "in", "the", "event", "that", "an", "Action", "hook", "is", "being", "requested", "." ]

[ "func", "runAsLibvirt", "(", "dir", ",", "command", "string", ",", "args", "...", "string", ")", "(", "string", ",", "error", ")", "{", "uid", ",", "gid", ",", "err", ":=", "getUserUIDGID", "(", "libvirtUser", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "cmd", ":=", "exec", ".", "Command", "(", "command", ",", "args", "...", ")", "\n", "if", "dir", "!=", "\"", "\"", "{", "cmd", ".", "Dir", "=", "dir", "\n", "}", "\n\n", "if", "dir", "==", "\"", "\"", "{", "dir", ",", "_", "=", "os", ".", "Getwd", "(", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "command", ",", "args", ",", "dir", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "uid", ",", "gid", ")", "\n\n", "cmd", ".", "SysProcAttr", "=", "&", "syscall", ".", "SysProcAttr", "{", "}", "\n", "cmd", ".", "SysProcAttr", ".", "Credential", "=", "&", "syscall", ".", "Credential", "{", "Uid", ":", "uint32", "(", "uid", ")", ",", "Gid", ":", "uint32", "(", "gid", ")", ",", "}", "\n\n", "out", ",", "err", ":=", "cmd", ".", "CombinedOutput", "(", ")", "\n", "output", ":=", "string", "(", "out", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "output", ")", "\n\n", "return", "output", ",", "err", "\n\n", "}" ]

[ "Run", "the", "command", "as", "user", "libvirt", "-", "qemu", "and", "return", "the", "combined", "output", ".", "If", "dir", "is", "non", "-", "empty", "use", "it", "as", "the", "working", "directory", "." ]

[ "func", "GenerateNetplan", "(", "interfaces", "[", "]", "network", ".", "InterfaceInfo", ")", "(", "string", ",", "error", ")", "{", "if", "len", "(", "interfaces", ")", "==", "0", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "interfaces", ")", "\n", "var", "netPlan", "netplan", ".", "Netplan", "\n", "netPlan", ".", "Network", ".", "Ethernets", "=", "make", "(", "map", "[", "string", "]", "netplan", ".", "Ethernet", ")", "\n", "netPlan", ".", "Network", ".", "Version", "=", "2", "\n", "for", "_", ",", "info", ":=", "range", "interfaces", "{", "var", "iface", "netplan", ".", "Ethernet", "\n", "if", "cidr", ":=", "info", ".", "CIDRAddress", "(", ")", ";", "cidr", "!=", "\"", "\"", "{", "iface", ".", "Addresses", "=", "append", "(", "iface", ".", "Addresses", ",", "cidr", ")", "\n", "}", "else", "if", "info", ".", "ConfigType", "==", "network", ".", "ConfigDHCP", "{", "t", ":=", "true", "\n", "iface", ".", "DHCP4", "=", "&", "t", "\n", "}", "\n\n", "for", "_", ",", "dns", ":=", "range", "info", ".", "DNSServers", "{", "iface", ".", "Nameservers", ".", "Addresses", "=", "append", "(", "iface", ".", "Nameservers", ".", "Addresses", ",", "dns", ".", "Value", ")", "\n", "}", "\n", "iface", ".", "Nameservers", ".", "Search", "=", "append", "(", "iface", ".", "Nameservers", ".", "Search", ",", "info", ".", "DNSSearchDomains", "...", ")", "\n\n", "if", "info", ".", "GatewayAddress", ".", "Value", "!=", "\"", "\"", "{", "switch", "{", "case", "info", ".", "GatewayAddress", ".", "Type", "==", "network", ".", "IPv4Address", ":", "iface", ".", "Gateway4", "=", "info", ".", "GatewayAddress", ".", "Value", "\n", "case", "info", ".", "GatewayAddress", ".", "Type", "==", "network", ".", "IPv6Address", ":", "iface", ".", "Gateway6", "=", "info", ".", "GatewayAddress", ".", "Value", "\n", "}", "\n", "}", "\n\n", "if", "info", ".", "MTU", "!=", "0", "&&", "info", ".", "MTU", "!=", "1500", "{", "iface", ".", "MTU", "=", "info", ".", "MTU", "\n", "}", "\n", "if", "info", ".", "MACAddress", "!=", "\"", "\"", "{", "iface", ".", "Match", "=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "info", ".", "MACAddress", "}", "\n", "}", "else", "{", "iface", ".", "Match", "=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "info", ".", "InterfaceName", "}", "\n", "}", "\n", "for", "_", ",", "route", ":=", "range", "info", ".", "Routes", "{", "route", ":=", "netplan", ".", "Route", "{", "To", ":", "route", ".", "DestinationCIDR", ",", "Via", ":", "route", ".", "GatewayIP", ",", "Metric", ":", "&", "route", ".", "Metric", ",", "}", "\n", "iface", ".", "Routes", "=", "append", "(", "iface", ".", "Routes", ",", "route", ")", "\n", "}", "\n", "netPlan", ".", "Network", ".", "Ethernets", "[", "info", ".", "InterfaceName", "]", "=", "iface", "\n", "}", "\n", "out", ",", "err", ":=", "netplan", ".", "Marshal", "(", "&", "netPlan", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "string", "(", "out", ")", ",", "nil", "\n", "}" ]

[ "GenerateNetplan", "renders", "a", "netplan", "file", "for", "one", "or", "more", "network", "interfaces", "using", "the", "given", "non", "-", "empty", "list", "of", "interfaces", "." ]

[ "func", "PrepareNetworkConfigFromInterfaces", "(", "interfaces", "[", "]", "network", ".", "InterfaceInfo", ")", "*", "PreparedConfig", "{", "dnsServers", ":=", "set", ".", "NewStrings", "(", ")", "\n", "dnsSearchDomains", ":=", "set", ".", "NewStrings", "(", ")", "\n", "gateway4Address", ":=", "\"", "\"", "\n", "gateway6Address", ":=", "\"", "\"", "\n", "namesInOrder", ":=", "make", "(", "[", "]", "string", ",", "1", ",", "len", "(", "interfaces", ")", "+", "1", ")", "\n", "nameToAddress", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "nameToRoutes", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "network", ".", "Route", ")", "\n", "nameToMTU", ":=", "make", "(", "map", "[", "string", "]", "int", ")", "\n\n", "// Always include the loopback.", "namesInOrder", "[", "0", "]", "=", "\"", "\"", "\n", "autoStarted", ":=", "set", ".", "NewStrings", "(", "\"", "\"", ")", "\n\n", "// We need to check if we have a host-provided default GW and use it.", "// Otherwise we'll use the first device with a gateway address,", "// it'll be filled in the second loop.", "for", "_", ",", "info", ":=", "range", "interfaces", "{", "if", "info", ".", "IsDefaultGateway", "{", "switch", "info", ".", "GatewayAddress", ".", "Type", "{", "case", "network", ".", "IPv4Address", ":", "gateway4Address", "=", "info", ".", "GatewayAddress", ".", "Value", "\n", "case", "network", ".", "IPv6Address", ":", "gateway6Address", "=", "info", ".", "GatewayAddress", ".", "Value", "\n", "}", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "info", ":=", "range", "interfaces", "{", "ifaceName", ":=", "strings", ".", "Replace", "(", "info", ".", "MACAddress", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "// prepend eth because .format of python wont like a tag starting with numbers.", "ifaceName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ifaceName", ")", "\n\n", "if", "!", "info", ".", "NoAutoStart", "{", "autoStarted", ".", "Add", "(", "ifaceName", ")", "\n", "}", "\n\n", "if", "cidr", ":=", "info", ".", "CIDRAddress", "(", ")", ";", "cidr", "!=", "\"", "\"", "{", "nameToAddress", "[", "ifaceName", "]", "=", "cidr", "\n", "}", "else", "if", "info", ".", "ConfigType", "==", "network", ".", "ConfigDHCP", "{", "nameToAddress", "[", "ifaceName", "]", "=", "string", "(", "network", ".", "ConfigDHCP", ")", "\n", "}", "\n", "nameToRoutes", "[", "ifaceName", "]", "=", "info", ".", "Routes", "\n\n", "for", "_", ",", "dns", ":=", "range", "info", ".", "DNSServers", "{", "dnsServers", ".", "Add", "(", "dns", ".", "Value", ")", "\n", "}", "\n\n", "dnsSearchDomains", "=", "dnsSearchDomains", ".", "Union", "(", "set", ".", "NewStrings", "(", "info", ".", "DNSSearchDomains", "...", ")", ")", "\n\n", "if", "info", ".", "GatewayAddress", ".", "Value", "!=", "\"", "\"", "{", "switch", "{", "case", "gateway4Address", "==", "\"", "\"", "&&", "info", ".", "GatewayAddress", ".", "Type", "==", "network", ".", "IPv4Address", ":", "gateway4Address", "=", "info", ".", "GatewayAddress", ".", "Value", "\n\n", "case", "gateway6Address", "==", "\"", "\"", "&&", "info", ".", "GatewayAddress", ".", "Type", "==", "network", ".", "IPv6Address", ":", "gateway6Address", "=", "info", ".", "GatewayAddress", ".", "Value", "\n", "}", "\n", "}", "\n\n", "if", "info", ".", "MTU", "!=", "0", "&&", "info", ".", "MTU", "!=", "1500", "{", "nameToMTU", "[", "ifaceName", "]", "=", "info", ".", "MTU", "\n", "}", "\n\n", "namesInOrder", "=", "append", "(", "namesInOrder", ",", "ifaceName", ")", "\n", "}", "\n\n", "prepared", ":=", "&", "PreparedConfig", "{", "InterfaceNames", ":", "namesInOrder", ",", "NameToAddress", ":", "nameToAddress", ",", "NameToRoutes", ":", "nameToRoutes", ",", "NameToMTU", ":", "nameToMTU", ",", "AutoStarted", ":", "autoStarted", ".", "SortedValues", "(", ")", ",", "DNSServers", ":", "dnsServers", ".", "SortedValues", "(", ")", ",", "DNSSearchDomains", ":", "dnsSearchDomains", ".", "SortedValues", "(", ")", ",", "Gateway4Address", ":", "gateway4Address", ",", "Gateway6Address", ":", "gateway6Address", ",", "}", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "prepared", ")", "\n", "return", "prepared", "\n", "}" ]

[ "PrepareNetworkConfigFromInterfaces", "collects", "the", "necessary", "information", "to", "render", "a", "persistent", "network", "config", "from", "the", "given", "slice", "of", "network", ".", "InterfaceInfo", ".", "The", "result", "always", "includes", "the", "loopback", "interface", "." ]

[ "func", "(", "config", "Config", ")", "Validate", "(", ")", "error", "{", "switch", "config", ".", "Scope", ".", "(", "type", ")", "{", "case", "nil", ":", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "case", "names", ".", "ModelTag", ":", "if", "config", ".", "StorageDir", "!=", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "names", ".", "MachineTag", ":", "if", "config", ".", "StorageDir", "==", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Machines", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "names", ".", "ApplicationTag", ":", "if", "config", ".", "StorageDir", "!=", "\"", "\"", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Applications", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "config", ".", "Scope", ")", "\n", "}", "\n", "if", "config", ".", "Volumes", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Filesystems", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Life", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Registry", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Status", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "Clock", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "config", ".", "CloudCallContext", "==", "nil", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "returns", "an", "error", "if", "the", "config", "cannot", "be", "relied", "upon", "to", "start", "a", "worker", "." ]