Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13k

[ "func", "(", "v", "*", "volumeAttachmentPlan", ")", "PlanInfo", "(", ")", "(", "VolumeAttachmentPlanInfo", ",", "error", ")", "{", "if", "v", ".", "doc", ".", "PlanInfo", "==", "nil", "{", "return", "VolumeAttachmentPlanInfo", "{", "}", ",", "errors", ".", "NotProvisionedf", "(", "\"", "\"", ",", "v", ".", "doc", ".", "Volume", ",", "v", ".", "doc", ".", "Machine", ")", "\n", "}", "\n", "return", "*", "v", ".", "doc", ".", "PlanInfo", ",", "nil", "\n", "}" ]

[ "PlanInfo", "is", "required", "to", "implement", "VolumeAttachment", "." ]

[ "func", "(", "v", "*", "volumeAttachment", ")", "Volume", "(", ")", "names", ".", "VolumeTag", "{", "return", "names", ".", "NewVolumeTag", "(", "v", ".", "doc", ".", "Volume", ")", "\n", "}" ]

[ "Volume", "is", "required", "to", "implement", "VolumeAttachment", "." ]

[ "func", "(", "v", "*", "volumeAttachment", ")", "Info", "(", ")", "(", "VolumeAttachmentInfo", ",", "error", ")", "{", "if", "v", ".", "doc", ".", "Info", "==", "nil", "{", "host", ":=", "storageAttachmentHost", "(", "v", ".", "doc", ".", "Host", ")", "\n", "return", "VolumeAttachmentInfo", "{", "}", ",", "errors", ".", "NotProvisionedf", "(", "\"", "\"", ",", "v", ".", "doc", ".", "Volume", ",", "names", ".", "ReadableString", "(", "host", ")", ")", "\n", "}", "\n", "return", "*", "v", ".", "doc", ".", "Info", ",", "nil", "\n", "}" ]

[ "Info", "is", "required", "to", "implement", "VolumeAttachment", "." ]

[ "func", "(", "v", "*", "volumeAttachment", ")", "Params", "(", ")", "(", "VolumeAttachmentParams", ",", "bool", ")", "{", "if", "v", ".", "doc", ".", "Params", "==", "nil", "{", "return", "VolumeAttachmentParams", "{", "}", ",", "false", "\n", "}", "\n", "return", "*", "v", ".", "doc", ".", "Params", ",", "true", "\n", "}" ]

[ "Params", "is", "required", "to", "implement", "VolumeAttachment", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "Volume", "(", "tag", "names", ".", "VolumeTag", ")", "(", "Volume", ",", "error", ")", "{", "v", ",", "err", ":=", "getVolumeByTag", "(", "sb", ".", "mb", ",", "tag", ")", "\n", "return", "v", ",", "err", "\n", "}" ]

[ "Volume", "returns", "the", "Volume", "with", "the", "specified", "name", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "StorageInstanceVolume", "(", "tag", "names", ".", "StorageTag", ")", "(", "Volume", ",", "error", ")", "{", "v", ",", "err", ":=", "sb", ".", "storageInstanceVolume", "(", "tag", ")", "\n", "return", "v", ",", "err", "\n", "}" ]

[ "StorageInstanceVolume", "returns", "the", "Volume", "assigned", "to", "the", "specified", "storage", "instance", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "VolumeAttachment", "(", "host", "names", ".", "Tag", ",", "volume", "names", ".", "VolumeTag", ")", "(", "VolumeAttachment", ",", "error", ")", "{", "coll", ",", "cleanup", ":=", "sb", ".", "mb", ".", "db", "(", ")", ".", "GetCollection", "(", "volumeAttachmentsC", ")", "\n", "defer", "cleanup", "(", ")", "\n\n", "var", "att", "volumeAttachment", "\n", "err", ":=", "coll", ".", "FindId", "(", "volumeAttachmentId", "(", "host", ".", "Id", "(", ")", ",", "volume", ".", "Id", "(", ")", ")", ")", ".", "One", "(", "&", "att", ".", "doc", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "volume", ".", "Id", "(", ")", ",", "names", ".", "ReadableString", "(", "host", ")", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "volume", ".", "Id", "(", ")", ",", "names", ".", "ReadableString", "(", "host", ")", ")", "\n", "}", "\n", "return", "&", "att", ",", "nil", "\n", "}" ]

[ "VolumeAttachment", "returns", "the", "VolumeAttachment", "corresponding", "to", "the", "specified", "volume", "and", "machine", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "MachineVolumeAttachments", "(", "machine", "names", ".", "MachineTag", ")", "(", "[", "]", "VolumeAttachment", ",", "error", ")", "{", "attachments", ",", "err", ":=", "sb", ".", "volumeAttachments", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "machine", ".", "Id", "(", ")", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "machine", ".", "Id", "(", ")", ")", "\n", "}", "\n", "return", "attachments", ",", "nil", "\n", "}" ]

[ "MachineVolumeAttachments", "returns", "all", "of", "the", "VolumeAttachments", "for", "the", "specified", "machine", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "UnitVolumeAttachments", "(", "unit", "names", ".", "UnitTag", ")", "(", "[", "]", "VolumeAttachment", ",", "error", ")", "{", "attachments", ",", "err", ":=", "sb", ".", "volumeAttachments", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "unit", ".", "Id", "(", ")", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "unit", ".", "Id", "(", ")", ")", "\n", "}", "\n", "return", "attachments", ",", "nil", "\n", "}" ]

[ "UnitVolumeAttachments", "returns", "all", "of", "the", "VolumeAttachments", "for", "the", "specified", "unit", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "VolumeAttachments", "(", "volume", "names", ".", "VolumeTag", ")", "(", "[", "]", "VolumeAttachment", ",", "error", ")", "{", "attachments", ",", "err", ":=", "sb", ".", "volumeAttachments", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "volume", ".", "Id", "(", ")", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "volume", ".", "Id", "(", ")", ")", "\n", "}", "\n", "return", "attachments", ",", "nil", "\n", "}" ]

[ "VolumeAttachments", "returns", "all", "of", "the", "VolumeAttachments", "for", "the", "specified", "volume", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "VolumeAttachmentPlans", "(", "volume", "names", ".", "VolumeTag", ")", "(", "[", "]", "VolumeAttachmentPlan", ",", "error", ")", "{", "attachmentPlans", ",", "err", ":=", "sb", ".", "volumeAttachmentPlans", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "volume", ".", "Id", "(", ")", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "volume", ".", "Id", "(", ")", ")", "\n", "}", "\n", "return", "attachmentPlans", ",", "nil", "\n", "}" ]

[ "VolumeAttachmentPlans", "returns", "all", "of", "the", "VolumeAttachmentPlans", "for", "the", "specified", "volume", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "removeMachineVolumesOps", "(", "m", "*", "Machine", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "// A machine cannot transition to Dead if it has any detachable storage", "// attached, so any attachments are for machine-bound storage.", "//", "// Even if a volume is \"non-detachable\", there still exist volume", "// attachments, and they may be removed independently of the volume.", "// For example, the user may request that the volume be destroyed.", "// This will cause the volume to become Dying, and the attachment to", "// be Dying, then Dead, and finally removed. Only once the attachment", "// is removed will the volume transition to Dead and then be removed.", "// Therefore, there may be volumes that are bound, but not attached,", "// to the machine.", "machineVolumes", ",", "err", ":=", "sb", ".", "volumes", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "m", ".", "Id", "(", ")", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", ":=", "make", "(", "[", "]", "txn", ".", "Op", ",", "0", ",", "2", "*", "len", "(", "machineVolumes", ")", "+", "len", "(", "m", ".", "doc", ".", "Volumes", ")", ")", "\n", "for", "_", ",", "volumeId", ":=", "range", "m", ".", "doc", ".", "Volumes", "{", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "volumeAttachmentsC", ",", "Id", ":", "volumeAttachmentId", "(", "m", ".", "Id", "(", ")", ",", "volumeId", ")", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Remove", ":", "true", ",", "}", ")", "\n", "}", "\n", "for", "_", ",", "v", ":=", "range", "machineVolumes", "{", "if", "v", ".", "doc", ".", "StorageId", "!=", "\"", "\"", "{", "// The volume is assigned to a storage instance;", "// make sure we also remove the storage instance.", "// There should be no storage attachments remaining,", "// as the units must have been removed before the", "// machine can be; and the storage attachments must", "// have been removed before the unit can be.", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "storageInstancesC", ",", "Id", ":", "v", ".", "doc", ".", "StorageId", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Remove", ":", "true", ",", "}", ",", ")", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "sb", ".", "removeVolumeOps", "(", "v", ".", "VolumeTag", "(", ")", ")", "...", ")", "\n", "}", "\n", "return", "ops", ",", "nil", "\n", "}" ]

[ "removeMachineVolumesOps", "returns", "txn", ".", "Ops", "to", "remove", "non", "-", "persistent", "volumes", "bound", "or", "attached", "to", "the", "specified", "machine", ".", "This", "is", "used", "when", "the", "given", "machine", "is", "being", "removed", "from", "state", "." ]

[ "func", "isDetachableVolumeTag", "(", "db", "Database", ",", "tag", "names", ".", "VolumeTag", ")", "(", "bool", ",", "error", ")", "{", "doc", ",", "err", ":=", "getVolumeDocByTag", "(", "db", ",", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "detachableVolumeDoc", "(", "&", "doc", ")", ",", "nil", "\n", "}" ]

[ "isDetachableVolumeTag", "reports", "whether", "or", "not", "the", "volume", "with", "the", "specified", "tag", "is", "detachable", "." ]

[ "func", "isDetachableVolumePool", "(", "im", "*", "storageBackend", ",", "pool", "string", ")", "(", "bool", ",", "error", ")", "{", "_", ",", "provider", ",", "_", ",", "err", ":=", "poolStorageProvider", "(", "im", ",", "pool", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "provider", ".", "Scope", "(", ")", "==", "storage", ".", "ScopeMachine", "{", "// Any storage created by a machine cannot be detached from", "// the machine, and must be destroyed along with it.", "return", "false", ",", "nil", "\n", "}", "\n", "if", "provider", ".", "Dynamic", "(", ")", "{", "// NOTE(axw) In theory, we don't know ahead of time", "// whether the storage will be Persistent, as the model", "// allows for a dynamic storage provider to create non-", "// persistent storage. None of the storage providers do", "// this, so we assume it will be persistent for now.", "//", "// TODO(axw) get rid of the Persistent field from Volume", "// and Filesystem. We only need to care whether the", "// storage is dynamic and model-scoped.", "return", "true", ",", "nil", "\n", "}", "\n", "// Volume is static, so it will be tied to the machine.", "return", "false", ",", "nil", "\n", "}" ]

[ "isDetachableVolumePool", "reports", "whether", "or", "not", "the", "given", "storage", "pool", "will", "create", "a", "volume", "that", "is", "not", "inherently", "bound", "to", "a", "machine", "and", "therefore", "can", "be", "detached", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "DetachVolume", "(", "host", "names", ".", "Tag", ",", "volume", "names", ".", "VolumeTag", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "volume", ".", "Id", "(", ")", ",", "names", ".", "ReadableString", "(", "host", ")", ")", "\n", "// If the volume is backing a filesystem, the volume cannot be detached", "// until the filesystem has been detached.", "if", "_", ",", "err", ":=", "sb", ".", "volumeFilesystemAttachment", "(", "host", ",", "volume", ")", ";", "err", "==", "nil", "{", "return", "&", "errContainsFilesystem", "{", "errors", ".", "New", "(", "\"", "\"", ")", "}", "\n", "}", "else", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "va", ",", "err", ":=", "sb", ".", "VolumeAttachment", "(", "host", ",", "volume", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "va", ".", "Life", "(", ")", "!=", "Alive", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "detachable", ",", "err", ":=", "isDetachableVolumeTag", "(", "sb", ".", "mb", ".", "db", "(", ")", ",", "volume", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "detachable", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "plans", ",", "err", ":=", "sb", ".", "machineVolumeAttachmentPlans", "(", "host", ",", "volume", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "else", "{", "if", "len", "(", "plans", ")", ">", "0", "{", "return", "detachStorageAttachmentOps", "(", "host", ",", "volume", ")", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "detachVolumeOps", "(", "host", ",", "volume", ")", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "DetachVolume", "marks", "the", "volume", "attachment", "identified", "by", "the", "specified", "machine", "and", "volume", "tags", "as", "Dying", "if", "it", "is", "Alive", ".", "DetachVolume", "will", "fail", "with", "a", "IsContainsFilesystem", "error", "if", "the", "volume", "contains", "an", "attached", "filesystem", ";", "the", "filesystem", "attachment", "must", "be", "removed", "first", ".", "DetachVolume", "will", "fail", "for", "inherently", "machine", "-", "bound", "volumes", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "RemoveVolumeAttachment", "(", "host", "names", ".", "Tag", ",", "volume", "names", ".", "VolumeTag", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "volume", ".", "Id", "(", ")", ",", "names", ".", "ReadableString", "(", "host", ")", ")", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "attachment", ",", "err", ":=", "sb", ".", "VolumeAttachment", "(", "host", ",", "volume", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "&&", "attempt", ">", "0", "{", "// We only ignore IsNotFound on attempts after the", "// first, since we expect the volume attachment to", "// be there initially.", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "attachment", ".", "Life", "(", ")", "!=", "Dying", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "v", ",", "err", ":=", "getVolumeByTag", "(", "sb", ".", "mb", ",", "volume", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "removeVolumeAttachmentOps", "(", "host", ",", "v", ")", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "RemoveVolumeAttachment", "removes", "the", "volume", "attachment", "from", "state", ".", "RemoveVolumeAttachment", "will", "fail", "if", "the", "attachment", "is", "not", "Dying", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "DestroyVolume", "(", "tag", "names", ".", "VolumeTag", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "if", "_", ",", "err", ":=", "sb", ".", "VolumeFilesystem", "(", "tag", ")", ";", "err", "==", "nil", "{", "return", "&", "errContainsFilesystem", "{", "errors", ".", "New", "(", "\"", "\"", ")", "}", "\n", "}", "else", "if", "!", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "volume", ",", "err", ":=", "getVolumeByTag", "(", "sb", ".", "mb", ",", "tag", ")", "\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", "volume", ".", "doc", ".", "StorageId", "!=", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "names", ".", "ReadableString", "(", "names", ".", "NewStorageTag", "(", "volume", ".", "doc", ".", "StorageId", ")", ")", ",", ")", "\n", "}", "\n", "if", "volume", ".", "Life", "(", ")", "!=", "Alive", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "hasNoStorageAssignment", ":=", "bson", ".", "D", "{", "{", "\"", "\"", ",", "[", "]", "bson", ".", "D", "{", "{", "{", "\"", "\"", ",", "\"", "\"", "}", "}", ",", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "false", "}", "}", "}", "}", ",", "}", "}", "}", "\n", "return", "destroyVolumeOps", "(", "sb", ",", "volume", ",", "false", ",", "hasNoStorageAssignment", ")", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "DestroyVolume", "ensures", "that", "the", "volume", "and", "any", "attachments", "to", "it", "will", "be", "destroyed", "and", "removed", "from", "state", "at", "some", "point", "in", "the", "future", ".", "DestroyVolume", "will", "fail", "with", "an", "IsContainsFilesystem", "error", "if", "the", "volume", "contains", "a", "filesystem", ";", "the", "filesystem", "must", "be", "fully", "removed", "first", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "RemoveVolume", "(", "tag", "names", ".", "VolumeTag", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "volume", ",", "err", ":=", "sb", ".", "Volume", "(", "tag", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "volume", ".", "Life", "(", ")", "!=", "Dead", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "sb", ".", "removeVolumeOps", "(", "tag", ")", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "RemoveVolume", "removes", "the", "volume", "from", "state", ".", "RemoveVolume", "will", "fail", "if", "the", "volume", "is", "not", "Dead", "which", "implies", "that", "it", "still", "has", "attachments", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "addVolumeOps", "(", "params", "VolumeParams", ",", "hostId", "string", ")", "(", "[", "]", "txn", ".", "Op", ",", "names", ".", "VolumeTag", ",", "error", ")", "{", "params", ",", "err", ":=", "sb", ".", "volumeParamsWithDefaults", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "names", ".", "VolumeTag", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "detachable", ",", "err", ":=", "isDetachableVolumePool", "(", "sb", ",", "params", ".", "Pool", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "names", ".", "VolumeTag", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "origHostId", ":=", "hostId", "\n", "hostId", ",", "err", "=", "sb", ".", "validateVolumeParams", "(", "params", ",", "hostId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "names", ".", "VolumeTag", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "name", ",", "err", ":=", "newVolumeName", "(", "sb", ".", "mb", ",", "hostId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "names", ".", "VolumeTag", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "statusDoc", ":=", "statusDoc", "{", "Status", ":", "status", ".", "Pending", ",", "Updated", ":", "sb", ".", "mb", ".", "clock", "(", ")", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ",", "}", "\n", "doc", ":=", "volumeDoc", "{", "Name", ":", "name", ",", "StorageId", ":", "params", ".", "storage", ".", "Id", "(", ")", ",", "}", "\n", "if", "params", ".", "volumeInfo", "!=", "nil", "{", "// We're importing an already provisioned volume into the", "// model. Set provisioned info rather than params, and set", "// the status to \"detached\".", "statusDoc", ".", "Status", "=", "status", ".", "Detached", "\n", "doc", ".", "Info", "=", "params", ".", "volumeInfo", "\n", "}", "else", "{", "// Every new volume is created with one attachment.", "doc", ".", "Params", "=", "&", "params", "\n", "doc", ".", "AttachmentCount", "=", "1", "\n", "}", "\n", "if", "!", "detachable", "{", "doc", ".", "HostId", "=", "origHostId", "\n", "}", "\n", "return", "sb", ".", "newVolumeOps", "(", "doc", ",", "statusDoc", ")", ",", "names", ".", "NewVolumeTag", "(", "name", ")", ",", "nil", "\n", "}" ]

[ "addVolumeOps", "returns", "txn", ".", "Ops", "to", "create", "a", "new", "volume", "with", "the", "specified", "parameters", ".", "If", "the", "supplied", "host", "ID", "is", "non", "-", "empty", "and", "the", "storage", "provider", "is", "machine", "-", "scoped", "then", "the", "volume", "will", "be", "scoped", "to", "that", "machine", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "validateVolumeParams", "(", "params", "VolumeParams", ",", "machineId", "string", ")", "(", "maybeMachineId", "string", ",", "_", "error", ")", "{", "if", "err", ":=", "validateStoragePool", "(", "sb", ",", "params", ".", "Pool", ",", "storage", ".", "StorageKindBlock", ",", "&", "machineId", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "params", ".", "Size", "==", "0", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "machineId", ",", "nil", "\n", "}" ]

[ "validateVolumeParams", "validates", "the", "volume", "parameters", "and", "returns", "the", "machine", "ID", "to", "use", "as", "the", "scope", "in", "the", "volume", "tag", "." ]

[ "func", "ParseVolumeAttachmentId", "(", "id", "string", ")", "(", "names", ".", "Tag", ",", "names", ".", "VolumeTag", ",", "error", ")", "{", "fields", ":=", "strings", ".", "SplitN", "(", "id", ",", "\"", "\"", ",", "2", ")", "\n", "isValidHost", ":=", "names", ".", "IsValidMachine", "(", "fields", "[", "0", "]", ")", "||", "names", ".", "IsValidUnit", "(", "fields", "[", "0", "]", ")", "\n", "if", "len", "(", "fields", ")", "!=", "2", "||", "!", "isValidHost", "||", "!", "names", ".", "IsValidVolume", "(", "fields", "[", "1", "]", ")", "{", "return", "names", ".", "MachineTag", "{", "}", ",", "names", ".", "VolumeTag", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "var", "hostTag", "names", ".", "Tag", "\n", "if", "names", ".", "IsValidMachine", "(", "fields", "[", "0", "]", ")", "{", "hostTag", "=", "names", ".", "NewMachineTag", "(", "fields", "[", "0", "]", ")", "\n", "}", "else", "{", "hostTag", "=", "names", ".", "NewUnitTag", "(", "fields", "[", "0", "]", ")", "\n", "}", "\n", "volumeTag", ":=", "names", ".", "NewVolumeTag", "(", "fields", "[", "1", "]", ")", "\n", "return", "hostTag", ",", "volumeTag", ",", "nil", "\n", "}" ]

[ "ParseVolumeAttachmentId", "parses", "a", "string", "as", "a", "volume", "attachment", "ID", "returning", "the", "host", "and", "volume", "components", "." ]

[ "func", "createMachineVolumeAttachmentsOps", "(", "hostId", "string", ",", "attachments", "[", "]", "volumeAttachmentTemplate", ")", "[", "]", "txn", ".", "Op", "{", "ops", ":=", "make", "(", "[", "]", "txn", ".", "Op", ",", "len", "(", "attachments", ")", ")", "\n", "for", "i", ",", "attachment", ":=", "range", "attachments", "{", "paramsCopy", ":=", "attachment", ".", "params", "\n", "ops", "[", "i", "]", "=", "txn", ".", "Op", "{", "C", ":", "volumeAttachmentsC", ",", "Id", ":", "volumeAttachmentId", "(", "hostId", ",", "attachment", ".", "tag", ".", "Id", "(", ")", ")", ",", "Assert", ":", "txn", ".", "DocMissing", ",", "Insert", ":", "&", "volumeAttachmentDoc", "{", "Volume", ":", "attachment", ".", "tag", ".", "Id", "(", ")", ",", "Host", ":", "hostId", ",", "Params", ":", "&", "paramsCopy", ",", "}", ",", "}", "\n", "if", "attachment", ".", "existing", "{", "ops", "=", "append", "(", "ops", ",", "txn", ".", "Op", "{", "C", ":", "volumesC", ",", "Id", ":", "attachment", ".", "tag", ".", "Id", "(", ")", ",", "Assert", ":", "txn", ".", "DocExists", ",", "Update", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", "}", "}", ",", "}", ")", "\n", "}", "\n", "}", "\n", "return", "ops", "\n", "}" ]

[ "createMachineVolumeAttachmentInfo", "creates", "volume", "attachments", "for", "the", "specified", "host", "and", "attachment", "parameters", "keyed", "by", "volume", "tags", ".", "The", "caller", "is", "responsible", "for", "incrementing", "the", "volume", "s", "attachmentcount", "field", "." ]

[ "func", "setMachineVolumeAttachmentInfo", "(", "sb", "*", "storageBackend", ",", "machineId", "string", ",", "attachments", "map", "[", "names", ".", "VolumeTag", "]", "VolumeAttachmentInfo", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "machineId", ")", "\n", "machineTag", ":=", "names", ".", "NewMachineTag", "(", "machineId", ")", "\n", "for", "volumeTag", ",", "info", ":=", "range", "attachments", "{", "if", "err", ":=", "sb", ".", "setVolumeAttachmentInfo", "(", "machineTag", ",", "volumeTag", ",", "info", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "volumeTag", ".", "Id", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setMachineVolumeAttachmentInfo", "sets", "the", "volume", "attachment", "info", "for", "the", "specified", "machine", ".", "Each", "volume", "attachment", "info", "structure", "is", "keyed", "by", "the", "name", "of", "the", "volume", "it", "corresponds", "to", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "SetVolumeAttachmentInfo", "(", "hostTag", "names", ".", "Tag", ",", "volumeTag", "names", ".", "VolumeTag", ",", "info", "VolumeAttachmentInfo", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "volumeTag", ".", "Id", "(", ")", ",", "hostTag", ".", "Id", "(", ")", ")", "\n", "v", ",", "err", ":=", "sb", ".", "Volume", "(", "volumeTag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Ensure volume is provisioned before setting attachment info.", "// A volume cannot go from being provisioned to unprovisioned,", "// so there is no txn.Op for this below.", "if", "_", ",", "err", ":=", "v", ".", "Info", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Also ensure the machine is provisioned.", "if", "_", ",", "ok", ":=", "hostTag", ".", "(", "names", ".", "MachineTag", ")", ";", "ok", "{", "m", ",", "err", ":=", "sb", ".", "machine", "(", "hostTag", ".", "Id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "m", ".", "InstanceId", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "sb", ".", "setVolumeAttachmentInfo", "(", "hostTag", ",", "volumeTag", ",", "info", ")", "\n", "}" ]

[ "SetVolumeAttachmentInfo", "sets", "the", "VolumeAttachmentInfo", "for", "the", "specified", "volume", "attachment", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "RemoveVolumeAttachmentPlan", "(", "hostTag", "names", ".", "Tag", ",", "volume", "names", ".", "VolumeTag", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "volume", ".", "Id", "(", ")", ",", "hostTag", ".", "Id", "(", ")", ")", "\n", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "plans", ",", "err", ":=", "sb", ".", "machineVolumeAttachmentPlans", "(", "hostTag", ",", "volume", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// We should only have one plan for a volume", "if", "plans", "!=", "nil", "&&", "len", "(", "plans", ")", ">", "0", "{", "if", "plans", "[", "0", "]", ".", "Life", "(", ")", "!=", "Dying", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "}", "else", "{", "return", "nil", ",", "jujutxn", ".", "ErrNoOperations", "\n", "}", "\n", "return", "removeVolumeAttachmentPlanOps", "(", "hostTag", ",", "volume", ")", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "RemoveVolumeAttachmentPlan", "removes", "the", "volume", "attachment", "plan", "from", "state", "." ]

[ "func", "removeVolumeAttachmentPlanOps", "(", "hostTag", "names", ".", "Tag", ",", "volume", "names", ".", "VolumeTag", ")", "[", "]", "txn", ".", "Op", "{", "detachOps", ":=", "detachVolumeOps", "(", "hostTag", ",", "volume", ")", "\n", "removeOps", ":=", "[", "]", "txn", ".", "Op", "{", "{", "C", ":", "volumeAttachmentPlanC", ",", "Id", ":", "volumeAttachmentId", "(", "hostTag", ".", "Id", "(", ")", ",", "volume", ".", "Id", "(", ")", ")", ",", "Assert", ":", "bson", ".", "D", "{", "{", "\"", "\"", ",", "Dying", "}", "}", ",", "Remove", ":", "true", ",", "}", "}", "\n", "removeOps", "=", "append", "(", "removeOps", ",", "detachOps", "...", ")", "\n", "return", "removeOps", "\n", "}" ]

[ "removeVolumeAttachmentPlanOps", "removes", "the", "plan", "from", "state", "and", "sets", "the", "volume", "attachment", "to", "Dying", ".", "this", "will", "trigger", "the", "storageprovisioner", "on", "the", "controller", "to", "eventually", "detach", "the", "volume", "from", "the", "machine", "." ]

[ "func", "setProvisionedVolumeInfo", "(", "sb", "*", "storageBackend", ",", "volumes", "map", "[", "names", ".", "VolumeTag", "]", "VolumeInfo", ")", "error", "{", "for", "volumeTag", ",", "info", ":=", "range", "volumes", "{", "if", "err", ":=", "sb", ".", "SetVolumeInfo", "(", "volumeTag", ",", "info", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setProvisionedVolumeInfo", "sets", "the", "initial", "info", "for", "newly", "provisioned", "volumes", ".", "If", "non", "-", "empty", "machineId", "must", "be", "the", "machine", "ID", "associated", "with", "the", "volumes", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "SetVolumeInfo", "(", "tag", "names", ".", "VolumeTag", ",", "info", "VolumeInfo", ")", "(", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "if", "info", ".", "VolumeId", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "// TODO(axw) we should reject info without VolumeId set; can't do this", "// until the providers all set it correctly.", "buildTxn", ":=", "func", "(", "attempt", "int", ")", "(", "[", "]", "txn", ".", "Op", ",", "error", ")", "{", "v", ",", "err", ":=", "sb", ".", "Volume", "(", "tag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// If the volume has parameters, unset them when", "// we set info for the first time, ensuring that", "// params and info are mutually exclusive.", "var", "unsetParams", "bool", "\n", "var", "ops", "[", "]", "txn", ".", "Op", "\n", "if", "params", ",", "ok", ":=", "v", ".", "Params", "(", ")", ";", "ok", "{", "info", ".", "Pool", "=", "params", ".", "Pool", "\n", "unsetParams", "=", "true", "\n", "}", "else", "{", "// Ensure immutable properties do not change.", "oldInfo", ",", "err", ":=", "v", ".", "Info", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "validateVolumeInfoChange", "(", "info", ",", "oldInfo", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "ops", "=", "append", "(", "ops", ",", "setVolumeInfoOps", "(", "tag", ",", "info", ",", "unsetParams", ")", "...", ")", "\n", "return", "ops", ",", "nil", "\n", "}", "\n", "return", "sb", ".", "mb", ".", "db", "(", ")", ".", "Run", "(", "buildTxn", ")", "\n", "}" ]

[ "SetVolumeInfo", "sets", "the", "VolumeInfo", "for", "the", "specified", "volume", "." ]

[ "func", "(", "sb", "*", "storageBackend", ")", "AllVolumes", "(", ")", "(", "[", "]", "Volume", ",", "error", ")", "{", "volumes", ",", "err", ":=", "sb", ".", "volumes", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "volumesToInterfaces", "(", "volumes", ")", ",", "nil", "\n", "}" ]

[ "AllVolumes", "returns", "all", "Volumes", "scoped", "to", "the", "model", "." ]

[ "func", "watchMachinesLoop", "(", "context", "updaterContext", ",", "machinesWatcher", "watcher", ".", "StringsWatcher", ")", "(", "err", "error", ")", "{", "p", ":=", "&", "updater", "{", "context", ":", "context", ",", "machines", ":", "make", "(", "map", "[", "names", ".", "MachineTag", "]", "chan", "struct", "{", "}", ")", ",", "machineDead", ":", "make", "(", "chan", "machine", ")", ",", "}", "\n", "defer", "func", "(", ")", "{", "// TODO(fwereade): is this a home-grown sync.WaitGroup or something?", "// strongly suspect these machine goroutines could be managed rather", "// less opaquely if we made them all workers.", "for", "len", "(", "p", ".", "machines", ")", ">", "0", "{", "delete", "(", "p", ".", "machines", ",", "(", "<-", "p", ".", "machineDead", ")", ".", "Tag", "(", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "p", ".", "context", ".", "dying", "(", ")", ":", "return", "p", ".", "context", ".", "errDying", "(", ")", "\n", "case", "ids", ",", "ok", ":=", "<-", "machinesWatcher", ".", "Changes", "(", ")", ":", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "tags", ":=", "make", "(", "[", "]", "names", ".", "MachineTag", ",", "len", "(", "ids", ")", ")", "\n", "for", "i", ":=", "range", "ids", "{", "tags", "[", "i", "]", "=", "names", ".", "NewMachineTag", "(", "ids", "[", "i", "]", ")", "\n", "}", "\n", "if", "err", ":=", "p", ".", "startMachines", "(", "tags", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "m", ":=", "<-", "p", ".", "machineDead", ":", "delete", "(", "p", ".", "machines", ",", "m", ".", "Tag", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "watchMachinesLoop", "watches", "for", "changes", "provided", "by", "the", "given", "machinesWatcher", "and", "starts", "machine", "goroutines", "to", "deal", "with", "them", "using", "the", "provided", "newMachineContext", "function", "to", "create", "the", "appropriate", "context", "for", "each", "new", "machine", "tag", "." ]

[ "func", "runMachine", "(", "context", "machineContext", ",", "m", "machine", ",", "changed", "<-", "chan", "struct", "{", "}", ",", "died", "chan", "<-", "machine", ",", "clock", "clock", ".", "Clock", ")", "{", "defer", "func", "(", ")", "{", "// We can't just send on the died channel because the", "// central loop might be trying to write to us on the", "// changed channel.", "for", "{", "select", "{", "case", "died", "<-", "m", ":", "return", "\n", "case", "<-", "changed", ":", "}", "\n", "}", "\n", "}", "(", ")", "\n", "if", "err", ":=", "machineLoop", "(", "context", ",", "m", ",", "changed", ",", "clock", ")", ";", "err", "!=", "nil", "{", "context", ".", "kill", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "runMachine", "processes", "the", "address", "and", "status", "publishing", "for", "a", "given", "machine", ".", "We", "assume", "that", "the", "machine", "is", "alive", "when", "this", "is", "first", "called", "." ]

[ "func", "pollInstanceInfo", "(", "context", "machineContext", ",", "m", "machine", ")", "(", "instInfo", "instanceInfo", ",", "err", "error", ")", "{", "instInfo", "=", "instanceInfo", "{", "}", "\n", "instId", ",", "err", ":=", "m", ".", "InstanceId", "(", ")", "\n", "// We can't ask the machine for its addresses if it isn't provisioned yet.", "if", "params", ".", "IsCodeNotProvisioned", "(", "err", ")", "{", "return", "instanceInfo", "{", "}", ",", "err", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "instanceInfo", "{", "}", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "instInfo", ",", "err", "=", "context", ".", "instanceInfo", "(", "instId", ")", "\n", "if", "err", "!=", "nil", "{", "// TODO (anastasiamac 2016-02-01) This does not look like it needs to be removed now.", "if", "params", ".", "IsCodeNotImplemented", "(", "err", ")", "{", "return", "instanceInfo", "{", "}", ",", "err", "\n", "}", "\n", "logger", ".", "Warningf", "(", "\"", "\"", ",", "instId", ",", "err", ")", "\n", "return", "instInfo", ",", "nil", "\n", "}", "\n", "if", "instStat", ",", "err", ":=", "m", ".", "InstanceStatus", "(", ")", ";", "err", "!=", "nil", "{", "// This should never occur since the machine is provisioned.", "// But just in case, we reset polled status so we try again next time.", "logger", ".", "Warningf", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ",", "err", ")", "\n", "instInfo", ".", "status", "=", "instance", ".", "Status", "{", "status", ".", "Unknown", ",", "\"", "\"", "}", "\n", "}", "else", "{", "// TODO(perrito666) add status validation.", "currentInstStatus", ":=", "instance", ".", "Status", "{", "Status", ":", "status", ".", "Status", "(", "instStat", ".", "Status", ")", ",", "Message", ":", "instStat", ".", "Info", ",", "}", "\n", "if", "instInfo", ".", "status", "!=", "currentInstStatus", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ",", "currentInstStatus", ",", "instInfo", ".", "status", ")", "\n", "if", "err", "=", "m", ".", "SetInstanceStatus", "(", "instInfo", ".", "status", ".", "Status", ",", "instInfo", ".", "status", ".", "Message", ",", "nil", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "m", ",", "err", ")", "\n", "return", "instanceInfo", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n\n", "}", "\n", "if", "m", ".", "Life", "(", ")", "!=", "params", ".", "Dead", "{", "providerAddresses", ",", "err", ":=", "m", ".", "ProviderAddresses", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "instanceInfo", "{", "}", ",", "err", "\n", "}", "\n", "if", "!", "addressesEqual", "(", "providerAddresses", ",", "instInfo", ".", "addresses", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "m", ".", "Id", "(", ")", ",", "instInfo", ".", "addresses", ")", "\n", "if", "err", ":=", "m", ".", "SetProviderAddresses", "(", "instInfo", ".", "addresses", "...", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "m", ",", "err", ")", "\n", "return", "instanceInfo", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "instInfo", ",", "nil", "\n", "}" ]

[ "pollInstanceInfo", "checks", "the", "current", "provider", "addresses", "and", "status", "for", "the", "given", "machine", "s", "instance", "and", "sets", "them", "on", "the", "machine", "if", "they", "ve", "changed", "." ]

[ "func", "addressesEqual", "(", "a0", ",", "a1", "[", "]", "network", ".", "Address", ")", "bool", "{", "if", "len", "(", "a0", ")", "!=", "len", "(", "a1", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "len", "(", "a0", ")", ",", "len", "(", "a1", ")", ",", "a0", ",", "a1", ")", "\n", "return", "false", "\n", "}", "\n\n", "ca0", ":=", "make", "(", "[", "]", "network", ".", "Address", ",", "len", "(", "a0", ")", ")", "\n", "copy", "(", "ca0", ",", "a0", ")", "\n", "network", ".", "SortAddresses", "(", "ca0", ")", "\n", "ca1", ":=", "make", "(", "[", "]", "network", ".", "Address", ",", "len", "(", "a1", ")", ")", "\n", "copy", "(", "ca1", ",", "a1", ")", "\n", "network", ".", "SortAddresses", "(", "ca1", ")", "\n\n", "for", "i", ":=", "range", "ca0", "{", "if", "ca0", "[", "i", "]", "!=", "ca1", "[", "i", "]", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "i", ",", "ca0", ",", "ca1", ")", "\n", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "addressesEqual", "compares", "the", "addresses", "of", "the", "machine", "and", "the", "instance", "information", "." ]

[ "func", "(", "c", "*", "modelStateCollection", ")", "Count", "(", ")", "(", "int", ",", "error", ")", "{", "return", "c", ".", "WriteCollection", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "c", ".", "modelUUID", "}", "}", ")", ".", "Count", "(", ")", "\n", "}" ]

[ "Count", "returns", "the", "number", "of", "documents", "in", "the", "collection", "that", "belong", "to", "the", "model", "that", "the", "modelStateCollection", "is", "filtering", "on", "." ]

[ "func", "(", "c", "*", "modelStateCollection", ")", "Insert", "(", "docs", "...", "interface", "{", "}", ")", "error", "{", "var", "mungedDocs", "[", "]", "interface", "{", "}", "\n", "for", "_", ",", "doc", ":=", "range", "docs", "{", "mungedDoc", ",", "err", ":=", "mungeDocForMultiModel", "(", "doc", ",", "c", ".", "modelUUID", ",", "modelUUIDRequired", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "mungedDocs", "=", "append", "(", "mungedDocs", ",", "mungedDoc", ")", "\n", "}", "\n", "return", "c", ".", "WriteCollection", ".", "Insert", "(", "mungedDocs", "...", ")", "\n", "}" ]

[ "Insert", "adds", "one", "or", "more", "documents", "to", "a", "collection", ".", "If", "the", "document", "id", "is", "a", "string", "the", "model", "UUID", "prefix", "will", "be", "automatically", "added", "to", "it", ".", "The", "model", "-", "uuid", "field", "will", "also", "be", "automatically", "added", "if", "it", "is", "missing", ".", "An", "error", "will", "be", "returned", "if", "an", "model", "-", "uuid", "field", "is", "provided", "but", "is", "the", "wrong", "value", "." ]

[ "func", "(", "c", "*", "modelStateCollection", ")", "UpdateId", "(", "id", "interface", "{", "}", ",", "update", "interface", "{", "}", ")", "error", "{", "if", "sid", ",", "ok", ":=", "id", ".", "(", "string", ")", ";", "ok", "{", "return", "c", ".", "WriteCollection", ".", "UpdateId", "(", "ensureModelUUID", "(", "c", ".", "modelUUID", ",", "sid", ")", ",", "update", ")", "\n", "}", "\n", "return", "c", ".", "WriteCollection", ".", "UpdateId", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "id", "}", "}", ",", "update", ")", "\n", "}" ]

[ "UpdateId", "finds", "a", "single", "document", "by", "_id", "and", "modifies", "it", "according", "to", "the", "update", "document", ".", "The", "id", "must", "be", "a", "string", "or", "bson", ".", "ObjectId", ".", "The", "model", "UUID", "will", "be", "automatically", "prefixed", "on", "to", "the", "id", "if", "it", "s", "a", "string", "and", "the", "prefix", "isn", "t", "there", "already", "." ]

[ "func", "getAllUnitNames", "(", "st", "*", "state", ".", "State", ",", "units", ",", "services", "[", "]", "string", ")", "(", "result", "[", "]", "names", ".", "Tag", ",", "err", "error", ")", "{", "var", "leaders", "map", "[", "string", "]", "string", "\n", "getLeader", ":=", "func", "(", "appName", "string", ")", "(", "string", ",", "error", ")", "{", "if", "leaders", "==", "nil", "{", "var", "err", "error", "\n", "leaders", ",", "err", "=", "st", ".", "ApplicationLeaders", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "\n", "if", "leader", ",", "ok", ":=", "leaders", "[", "appName", "]", ";", "ok", "{", "return", "leader", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "appName", ")", "\n", "}", "\n\n", "// Replace units matching $app/leader with the appropriate unit for", "// the leader.", "unitsSet", ":=", "set", ".", "NewStrings", "(", ")", "\n", "for", "_", ",", "unit", ":=", "range", "units", "{", "if", "!", "strings", ".", "HasSuffix", "(", "unit", ",", "\"", "\"", ")", "{", "unitsSet", ".", "Add", "(", "unit", ")", "\n", "continue", "\n", "}", "\n\n", "app", ":=", "strings", ".", "Split", "(", "unit", ",", "\"", "\"", ")", "[", "0", "]", "\n", "leaderUnit", ",", "err", ":=", "getLeader", "(", "app", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n\n", "unitsSet", ".", "Add", "(", "leaderUnit", ")", "\n", "}", "\n\n", "for", "_", ",", "name", ":=", "range", "services", "{", "service", ",", "err", ":=", "st", ".", "Application", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "units", ",", "err", ":=", "service", ".", "AllUnits", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "unit", ":=", "range", "units", "{", "unitsSet", ".", "Add", "(", "unit", ".", "Name", "(", ")", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "unitName", ":=", "range", "unitsSet", ".", "SortedValues", "(", ")", "{", "if", "!", "names", ".", "IsValidUnit", "(", "unitName", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "unitName", ")", "\n", "}", "\n", "result", "=", "append", "(", "result", ",", "names", ".", "NewUnitTag", "(", "unitName", ")", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "getAllUnitNames", "returns", "a", "sequence", "of", "valid", "Unit", "objects", "from", "state", ".", "If", "any", "of", "the", "application", "names", "or", "unit", "names", "are", "not", "found", "an", "error", "is", "returned", "." ]

[ "func", "(", "a", "*", "ActionAPI", ")", "Run", "(", "run", "params", ".", "RunParams", ")", "(", "results", "params", ".", "ActionResults", ",", "err", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanAdmin", "(", ")", ";", "err", "!=", "nil", "{", "return", "results", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "check", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "units", ",", "err", ":=", "getAllUnitNames", "(", "a", ".", "state", ",", "run", ".", "Units", ",", "run", ".", "Applications", ")", "\n", "if", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "machines", ":=", "make", "(", "[", "]", "names", ".", "Tag", ",", "len", "(", "run", ".", "Machines", ")", ")", "\n", "for", "i", ",", "machineId", ":=", "range", "run", ".", "Machines", "{", "if", "!", "names", ".", "IsValidMachine", "(", "machineId", ")", "{", "return", "results", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "machineId", ")", "\n", "}", "\n", "machines", "[", "i", "]", "=", "names", ".", "NewMachineTag", "(", "machineId", ")", "\n", "}", "\n\n", "actionParams", ":=", "a", ".", "createActionsParams", "(", "append", "(", "units", ",", "machines", "...", ")", ",", "run", ".", "Commands", ",", "run", ".", "Timeout", ")", "\n\n", "return", "queueActions", "(", "a", ",", "actionParams", ")", "\n", "}" ]

[ "Run", "the", "commands", "specified", "on", "the", "machines", "identified", "through", "the", "list", "of", "machines", "units", "and", "services", "." ]

[ "func", "(", "a", "*", "ActionAPI", ")", "RunOnAllMachines", "(", "run", "params", ".", "RunParams", ")", "(", "results", "params", ".", "ActionResults", ",", "err", "error", ")", "{", "if", "err", ":=", "a", ".", "checkCanAdmin", "(", ")", ";", "err", "!=", "nil", "{", "return", "results", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "check", ".", "ChangeAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "results", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "machines", ",", "err", ":=", "a", ".", "state", ".", "AllMachines", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "results", ",", "err", "\n", "}", "\n", "machineTags", ":=", "make", "(", "[", "]", "names", ".", "Tag", ",", "len", "(", "machines", ")", ")", "\n", "for", "i", ",", "machine", ":=", "range", "machines", "{", "machineTags", "[", "i", "]", "=", "machine", ".", "Tag", "(", ")", "\n", "}", "\n\n", "actionParams", ":=", "a", ".", "createActionsParams", "(", "machineTags", ",", "run", ".", "Commands", ",", "run", ".", "Timeout", ")", "\n\n", "return", "queueActions", "(", "a", ",", "actionParams", ")", "\n", "}" ]

[ "RunOnAllMachines", "attempts", "to", "run", "the", "specified", "command", "on", "all", "the", "machines", "." ]

[ "func", "bounceErrChanged", "(", "err", "error", ")", "error", "{", "if", "errors", ".", "Cause", "(", "err", ")", "==", "ErrChanged", "{", "return", "dependency", ".", "ErrBounce", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "bounceErrChanged", "converts", "ErrChanged", "to", "dependency", ".", "ErrBounce", "." ]

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

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

[ "func", "hookToolMain", "(", "commandName", "string", ",", "ctx", "*", "cmd", ".", "Context", ",", "args", "[", "]", "string", ")", "(", "code", "int", ",", "err", "error", ")", "{", "code", "=", "1", "\n", "contextId", ",", "err", ":=", "getenv", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "dir", ",", "err", ":=", "getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "req", ":=", "jujuc", ".", "Request", "{", "ContextId", ":", "contextId", ",", "Dir", ":", "dir", ",", "CommandName", ":", "commandName", ",", "Args", ":", "args", "[", "1", ":", "]", ",", "}", "\n", "socketPath", ",", "err", ":=", "getenv", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "client", ",", "err", ":=", "sockets", ".", "Dial", "(", "socketPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "var", "resp", "exec", ".", "ExecResponse", "\n", "err", "=", "client", ".", "Call", "(", "\"", "\"", ",", "req", ",", "&", "resp", ")", "\n", "if", "err", "!=", "nil", "&&", "err", ".", "Error", "(", ")", "==", "jujuc", ".", "ErrNoStdin", ".", "Error", "(", ")", "{", "req", ".", "Stdin", ",", "err", "=", "ioutil", ".", "ReadAll", "(", "os", ".", "Stdin", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "req", ".", "StdinSet", "=", "true", "\n", "err", "=", "client", ".", "Call", "(", "\"", "\"", ",", "req", ",", "&", "resp", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "os", ".", "Stdout", ".", "Write", "(", "resp", ".", "Stdout", ")", "\n", "os", ".", "Stderr", ".", "Write", "(", "resp", ".", "Stderr", ")", "\n", "return", "resp", ".", "Code", ",", "nil", "\n", "}" ]

[ "hookToolMain", "uses", "JUJU_CONTEXT_ID", "and", "JUJU_AGENT_SOCKET", "to", "ask", "a", "running", "unit", "agent", "to", "execute", "a", "Command", "on", "our", "behalf", ".", "Individual", "commands", "should", "be", "exposed", "by", "symlinking", "the", "command", "name", "to", "this", "executable", "." ]

[ "func", "jujuDMain", "(", "args", "[", "]", "string", ",", "ctx", "*", "cmd", ".", "Context", ")", "(", "code", "int", ",", "err", "error", ")", "{", "// Assuming an average of 200 bytes per log message, use up to", "// 200MB for the log buffer.", "defer", "logger", ".", "Debugf", "(", "\"", "\"", ",", "code", ",", "err", ")", "\n", "bufferedLogger", ",", "err", ":=", "logsender", ".", "InstallBufferedLogWriter", "(", "1048576", ")", "\n", "if", "err", "!=", "nil", "{", "return", "1", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "// Set the default transport to use the in-process proxy", "// configuration.", "if", "err", ":=", "proxy", ".", "DefaultConfig", ".", "Set", "(", "proxyutils", ".", "DetectProxies", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "1", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "proxy", ".", "DefaultConfig", ".", "InstallInDefaultTransport", "(", ")", ";", "err", "!=", "nil", "{", "return", "1", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "jujud", ":=", "jujucmd", ".", "NewSuperCommand", "(", "cmd", ".", "SuperCommandParams", "{", "Name", ":", "\"", "\"", ",", "Doc", ":", "jujudDoc", ",", "}", ")", "\n\n", "jujud", ".", "Log", ".", "NewWriter", "=", "func", "(", "target", "io", ".", "Writer", ")", "loggo", ".", "Writer", "{", "return", "&", "jujudWriter", "{", "target", ":", "target", "}", "\n", "}", "\n\n", "jujud", ".", "Register", "(", "agentcmd", ".", "NewBootstrapCommand", "(", ")", ")", "\n\n", "// TODO(katco-): AgentConf type is doing too much. The", "// MachineAgent type has called out the separate concerns; the", "// AgentConf should be split up to follow suit.", "agentConf", ":=", "agentcmd", ".", "NewAgentConf", "(", "\"", "\"", ")", "\n", "machineAgentFactory", ":=", "agentcmd", ".", "MachineAgentFactoryFn", "(", "agentConf", ",", "bufferedLogger", ",", "agentcmd", ".", "DefaultIntrospectionSocketName", ",", "upgrades", ".", "PreUpgradeSteps", ",", "\"", "\"", ",", ")", "\n", "jujud", ".", "Register", "(", "agentcmd", ".", "NewMachineAgentCmd", "(", "ctx", ",", "machineAgentFactory", ",", "agentConf", ",", "agentConf", ")", ")", "\n\n", "unitAgent", ",", "err", ":=", "agentcmd", ".", "NewUnitAgent", "(", "ctx", ",", "bufferedLogger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "jujud", ".", "Register", "(", "unitAgent", ")", "\n\n", "caasOperatorAgent", ",", "err", ":=", "agentcmd", ".", "NewCaasOperatorAgent", "(", "ctx", ",", "bufferedLogger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "jujud", ".", "Register", "(", "caasOperatorAgent", ")", "\n\n", "jujud", ".", "Register", "(", "agentcmd", ".", "NewCheckConnectionCommand", "(", "agentConf", ",", "agentcmd", ".", "ConnectAsAgent", ")", ")", "\n\n", "code", "=", "cmd", ".", "Main", "(", "jujud", ",", "ctx", ",", "args", "[", "1", ":", "]", ")", "\n", "return", "code", ",", "nil", "\n", "}" ]

[ "Main", "registers", "subcommands", "for", "the", "jujud", "executable", "and", "hands", "over", "control", "to", "the", "cmd", "package", "." ]

[ "func", "(", "p", "*", "provisioner", ")", "saveApplicationWorker", "(", "appName", "string", ",", "aw", "worker", ".", "Worker", ")", "{", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "p", ".", "provisioners", "==", "nil", "{", "p", ".", "provisioners", "=", "make", "(", "map", "[", "string", "]", "worker", ".", "Worker", ")", "\n", "}", "\n", "p", ".", "provisioners", "[", "appName", "]", "=", "aw", "\n", "}" ]

[ "These", "helper", "methods", "protect", "the", "provisioners", "map", "so", "we", "can", "access", "for", "testing", "." ]

[ "func", "(", "c", "*", "Client", ")", "RunOnAllMachines", "(", "commands", "string", ",", "timeout", "time", ".", "Duration", ")", "(", "[", "]", "params", ".", "ActionResult", ",", "error", ")", "{", "var", "results", "params", ".", "ActionResults", "\n", "args", ":=", "params", ".", "RunParams", "{", "Commands", ":", "commands", ",", "Timeout", ":", "timeout", "}", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "results", ")", "\n", "return", "results", ".", "Results", ",", "err", "\n", "}" ]

[ "RunOnAllMachines", "runs", "the", "command", "on", "all", "the", "machines", "with", "the", "specified", "timeout", "." ]

[ "func", "(", "c", "*", "Client", ")", "Run", "(", "run", "params", ".", "RunParams", ")", "(", "[", "]", "params", ".", "ActionResult", ",", "error", ")", "{", "var", "results", "params", ".", "ActionResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "run", ",", "&", "results", ")", "\n", "return", "results", ".", "Results", ",", "err", "\n", "}" ]

[ "Run", "the", "Commands", "specified", "on", "the", "machines", "identified", "through", "the", "ids", "provided", "in", "the", "machines", "applications", "and", "units", "slices", "." ]

[ "func", "(", "g", "EnvironConfigGetter", ")", "CloudAPIVersion", "(", "spec", "environs", ".", "CloudSpec", ")", "(", "string", ",", "error", ")", "{", "// Only CAAS models have an API version we care about right now.", "if", "g", ".", "Model", ".", "Type", "(", ")", "==", "state", ".", "ModelTypeIAAS", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "cfg", ",", "err", ":=", "g", ".", "ModelConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ctrlCfg", ",", "err", ":=", "g", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "newBroker", ":=", "g", ".", "NewContainerBroker", "\n", "if", "newBroker", "==", "nil", "{", "newBroker", "=", "caas", ".", "New", "\n", "}", "\n", "broker", ",", "err", ":=", "newBroker", "(", "environs", ".", "OpenParams", "{", "ControllerUUID", ":", "ctrlCfg", ".", "ControllerUUID", "(", ")", ",", "Cloud", ":", "spec", ",", "Config", ":", "cfg", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "broker", ".", "APIVersion", "(", ")", "\n", "}" ]

[ "CloudAPIVersion", "returns", "the", "cloud", "API", "version", "for", "the", "cloud", "with", "the", "given", "spec", "." ]

[ "func", "GetNewEnvironFunc", "(", "newEnviron", "environs", ".", "NewEnvironFunc", ")", "NewEnvironFunc", "{", "return", "func", "(", "st", "*", "state", ".", "State", ")", "(", "environs", ".", "Environ", ",", "error", ")", "{", "m", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "g", ":=", "EnvironConfigGetter", "{", "State", ":", "st", ",", "Model", ":", "m", "}", "\n", "return", "environs", ".", "GetEnviron", "(", "g", ",", "newEnviron", ")", "\n", "}", "\n", "}" ]

[ "GetNewEnvironFunc", "returns", "a", "NewEnvironFunc", "that", "constructs", "Environs", "using", "the", "given", "environs", ".", "NewEnvironFunc", "." ]

[ "func", "GetNewCAASBrokerFunc", "(", "newBroker", "caas", ".", "NewContainerBrokerFunc", ")", "NewCAASBrokerFunc", "{", "return", "func", "(", "st", "*", "state", ".", "State", ")", "(", "caas", ".", "Broker", ",", "error", ")", "{", "m", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "g", ":=", "EnvironConfigGetter", "{", "State", ":", "st", ",", "Model", ":", "m", "}", "\n", "cloudSpec", ",", "err", ":=", "g", ".", "CloudSpec", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "cfg", ",", "err", ":=", "g", ".", "ModelConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ctrlCfg", ",", "err", ":=", "g", ".", "ControllerConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "newBroker", "(", "environs", ".", "OpenParams", "{", "ControllerUUID", ":", "ctrlCfg", ".", "ControllerUUID", "(", ")", ",", "Cloud", ":", "cloudSpec", ",", "Config", ":", "cfg", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "GetNewCAASBrokerFunc", "returns", "a", "NewCAASBrokerFunc", "that", "constructs", "CAAS", "brokers", "using", "the", "given", "caas", ".", "NewContainerBrokerFunc", "." ]

[ "func", "(", "st", "*", "State", ")", "setModelAccess", "(", "access", "permission", ".", "Access", ",", "userGlobalKey", ",", "modelUUID", "string", ")", "error", "{", "if", "err", ":=", "permission", ".", "ValidateModelAccess", "(", "access", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "op", ":=", "updatePermissionOp", "(", "modelKey", "(", "modelUUID", ")", ",", "userGlobalKey", ",", "access", ")", "\n", "err", ":=", "st", ".", "db", "(", ")", ".", "RunTransactionFor", "(", "modelUUID", ",", "[", "]", "txn", ".", "Op", "{", "op", "}", ")", "\n", "if", "err", "==", "txn", ".", "ErrAborted", "{", "return", "errors", ".", "NotFoundf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "setModelAccess", "changes", "the", "user", "s", "access", "permissions", "on", "the", "model", "." ]

[ "func", "(", "m", "*", "Model", ")", "LastModelConnection", "(", "user", "names", ".", "UserTag", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "lastConnections", ",", "closer", ":=", "m", ".", "st", ".", "db", "(", ")", ".", "GetRawCollection", "(", "modelUserLastConnectionC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "username", ":=", "user", ".", "Id", "(", ")", "\n", "var", "lastConn", "modelUserLastConnectionDoc", "\n", "err", ":=", "lastConnections", ".", "FindId", "(", "m", ".", "st", ".", "docID", "(", "username", ")", ")", ".", "Select", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "1", "}", "}", ")", ".", "One", "(", "&", "lastConn", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "err", "=", "errors", ".", "Wrap", "(", "err", ",", "NeverConnectedError", "(", "username", ")", ")", "\n", "}", "\n", "return", "time", ".", "Time", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "lastConn", ".", "LastConnection", ".", "UTC", "(", ")", ",", "nil", "\n", "}" ]

[ "LastModelConnection", "returns", "when", "this", "User", "last", "connected", "through", "the", "API", "in", "UTC", ".", "The", "resulting", "time", "will", "be", "nil", "if", "the", "user", "has", "never", "logged", "in", "." ]

[ "func", "IsNeverConnectedError", "(", "err", "error", ")", "bool", "{", "_", ",", "ok", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "NeverConnectedError", ")", "\n", "return", "ok", "\n", "}" ]

[ "IsNeverConnectedError", "returns", "true", "if", "err", "is", "of", "type", "NeverConnectedError", "." ]

[ "func", "(", "m", "*", "Model", ")", "UpdateLastModelConnection", "(", "user", "names", ".", "UserTag", ")", "error", "{", "return", "m", ".", "updateLastModelConnection", "(", "user", ",", "m", ".", "st", ".", "nowToTheSecond", "(", ")", ")", "\n", "}" ]

[ "UpdateLastModelConnection", "updates", "the", "last", "connection", "time", "of", "the", "model", "user", "." ]

[ "func", "(", "st", "*", "State", ")", "modelUser", "(", "modelUUID", "string", ",", "user", "names", ".", "UserTag", ")", "(", "userAccessDoc", ",", "error", ")", "{", "modelUser", ":=", "userAccessDoc", "{", "}", "\n", "modelUsers", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollectionFor", "(", "modelUUID", ",", "modelUsersC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "username", ":=", "strings", ".", "ToLower", "(", "user", ".", "Id", "(", ")", ")", "\n", "err", ":=", "modelUsers", ".", "FindId", "(", "username", ")", ".", "One", "(", "&", "modelUser", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "userAccessDoc", "{", "}", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "username", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "userAccessDoc", "{", "}", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// DateCreated is inserted as UTC, but read out as local time. So we", "// convert it back to UTC here.", "modelUser", ".", "DateCreated", "=", "modelUser", ".", "DateCreated", ".", "UTC", "(", ")", "\n", "return", "modelUser", ",", "nil", "\n", "}" ]

[ "ModelUser", "a", "model", "userAccessDoc", "." ]

[ "func", "(", "st", "*", "State", ")", "removeModelUser", "(", "user", "names", ".", "UserTag", ")", "error", "{", "ops", ":=", "removeModelUserOps", "(", "st", ".", "ModelUUID", "(", ")", ",", "user", ")", "\n", "err", ":=", "st", ".", "db", "(", ")", ".", "RunTransaction", "(", "ops", ")", "\n", "if", "err", "==", "txn", ".", "ErrAborted", "{", "err", "=", "errors", ".", "NewNotFound", "(", "nil", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "user", ".", "Id", "(", ")", ")", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "removeModelUser", "removes", "a", "user", "from", "the", "database", "." ]

[ "func", "(", "st", "*", "State", ")", "isUserSuperuser", "(", "user", "names", ".", "UserTag", ")", "(", "bool", ",", "error", ")", "{", "access", ",", "err", ":=", "st", ".", "UserAccess", "(", "user", ",", "st", ".", "controllerTag", ")", "\n", "if", "err", "!=", "nil", "{", "// TODO(jam): 2017-11-27 We weren't suppressing NotFound here so that we would know when someone asked for", "// the list of models of a user that doesn't exist.", "// However, now we will not even check if its a known user if they aren't asking for all=true.", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "isControllerSuperuser", ":=", "(", "access", ".", "Access", "==", "permission", ".", "SuperuserAccess", ")", "\n", "return", "isControllerSuperuser", ",", "nil", "\n", "}" ]

[ "isUserSuperuser", "if", "this", "user", "has", "the", "Superuser", "access", "on", "the", "controller", "." ]

[ "func", "(", "st", "*", "State", ")", "modelQueryForUser", "(", "user", "names", ".", "UserTag", ",", "isSuperuser", "bool", ")", "(", "mongo", ".", "Query", ",", "SessionCloser", ",", "error", ")", "{", "var", "modelQuery", "mongo", ".", "Query", "\n", "models", ",", "closer", ":=", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "modelsC", ")", "\n", "if", "isSuperuser", "{", "// Fast path, we just return all the models that aren't Importing", "modelQuery", "=", "models", ".", "Find", "(", "bson", ".", "M", "{", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "MigrationModeImporting", "}", "}", ")", "\n", "}", "else", "{", "// Start by looking up model uuids that the user has access to, and then load only the records that are", "// included in that set", "var", "modelUUID", "struct", "{", "UUID", "string", "`bson:\"object-uuid\"`", "\n", "}", "\n", "modelUsers", ",", "userCloser", ":=", "st", ".", "db", "(", ")", ".", "GetRawCollection", "(", "modelUsersC", ")", "\n", "defer", "userCloser", "(", ")", "\n", "query", ":=", "modelUsers", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "user", ".", "Id", "(", ")", "}", "}", ")", "\n", "query", ".", "Select", "(", "bson", ".", "M", "{", "\"", "\"", ":", "1", ",", "\"", "\"", ":", "0", "}", ")", "\n", "query", ".", "Batch", "(", "100", ")", "\n", "iter", ":=", "query", ".", "Iter", "(", ")", "\n", "var", "modelUUIDs", "[", "]", "string", "\n", "for", "iter", ".", "Next", "(", "&", "modelUUID", ")", "{", "modelUUIDs", "=", "append", "(", "modelUUIDs", ",", "modelUUID", ".", "UUID", ")", "\n", "}", "\n", "if", "err", ":=", "iter", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "closer", "(", ")", "\n", "return", "nil", ",", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "modelQuery", "=", "models", ".", "Find", "(", "bson", ".", "M", "{", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "modelUUIDs", "}", ",", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "MigrationModeImporting", "}", ",", "}", ")", "\n", "}", "\n", "modelQuery", ".", "Sort", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "modelQuery", ",", "closer", ",", "nil", "\n", "}" ]

[ "modelsForUser", "gives", "you", "the", "information", "about", "all", "models", "that", "a", "user", "has", "access", "to", ".", "This", "includes", "the", "name", "and", "UUID", "as", "well", "as", "the", "last", "time", "the", "user", "connected", "to", "that", "model", "." ]

[ "func", "(", "st", "*", "State", ")", "ModelBasicInfoForUser", "(", "user", "names", ".", "UserTag", ")", "(", "[", "]", "ModelAccessInfo", ",", "error", ")", "{", "isSuperuser", ",", "err", ":=", "st", ".", "isUserSuperuser", "(", "user", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "modelQuery", ",", "closer1", ",", "err", ":=", "st", ".", "modelQueryForUser", "(", "user", ",", "isSuperuser", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "closer1", "(", ")", "\n", "modelQuery", ".", "Select", "(", "bson", ".", "M", "{", "\"", "\"", ":", "1", ",", "\"", "\"", ":", "1", ",", "\"", "\"", ":", "1", ",", "\"", "\"", ":", "1", "}", ")", "\n", "var", "accessInfo", "[", "]", "ModelAccessInfo", "\n", "if", "err", ":=", "modelQuery", ".", "All", "(", "&", "accessInfo", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// Now we need to find the last-connection time for each model for this user", "username", ":=", "user", ".", "Id", "(", ")", "\n", "connDocIds", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "accessInfo", ")", ")", "\n", "for", "i", ",", "acc", ":=", "range", "accessInfo", "{", "connDocIds", "[", "i", "]", "=", "acc", ".", "UUID", "+", "\"", "\"", "+", "username", "\n", "}", "\n", "lastConnections", ",", "closer2", ":=", "st", ".", "db", "(", ")", ".", "GetRawCollection", "(", "modelUserLastConnectionC", ")", "\n", "defer", "closer2", "(", ")", "\n", "query", ":=", "lastConnections", ".", "Find", "(", "bson", ".", "M", "{", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "connDocIds", "}", "}", ")", "\n", "query", ".", "Select", "(", "bson", ".", "M", "{", "\"", "\"", ":", "1", ",", "\"", "\"", ":", "0", ",", "\"", "\"", ":", "1", "}", ")", "\n", "query", ".", "Batch", "(", "100", ")", "\n", "iter", ":=", "query", ".", "Iter", "(", ")", "\n", "lastConns", ":=", "make", "(", "map", "[", "string", "]", "time", ".", "Time", ",", "len", "(", "connDocIds", ")", ")", "\n", "var", "connInfo", "modelUserLastConnectionDoc", "\n", "for", "iter", ".", "Next", "(", "&", "connInfo", ")", "{", "lastConns", "[", "connInfo", ".", "ModelUUID", "]", "=", "connInfo", ".", "LastConnection", "\n", "}", "\n", "if", "err", ":=", "iter", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "i", ":=", "range", "accessInfo", "{", "uuid", ":=", "accessInfo", "[", "i", "]", ".", "UUID", "\n", "accessInfo", "[", "i", "]", ".", "LastConnection", "=", "lastConns", "[", "uuid", "]", "\n", "}", "\n", "return", "accessInfo", ",", "nil", "\n", "}" ]

[ "ModelBasicInfoForUser", "gives", "you", "the", "information", "about", "all", "models", "that", "a", "user", "has", "access", "to", ".", "This", "includes", "the", "name", "and", "UUID", "as", "well", "as", "the", "last", "time", "the", "user", "connected", "to", "that", "model", "." ]

[ "func", "(", "st", "*", "State", ")", "IsControllerAdmin", "(", "user", "names", ".", "UserTag", ")", "(", "bool", ",", "error", ")", "{", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ua", ",", "err", ":=", "st", ".", "UserAccess", "(", "user", ",", "model", ".", "ControllerTag", "(", ")", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "ua", ".", "Access", "==", "permission", ".", "SuperuserAccess", ",", "nil", "\n", "}" ]

[ "IsControllerAdmin", "returns", "true", "if", "the", "user", "specified", "has", "Super", "User", "Access", "." ]

[ "func", "(", "s", "APIHostPortsSetter", ")", "SetAPIHostPorts", "(", "servers", "[", "]", "[", "]", "network", ".", "HostPort", ")", "error", "{", "return", "s", ".", "ChangeConfig", "(", "func", "(", "c", "ConfigSetter", ")", "error", "{", "c", ".", "SetAPIHostPorts", "(", "servers", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "SetAPIHostPorts", "is", "the", "APIAddressSetter", "interface", "." ]

[ "func", "(", "p", "*", "Paths", ")", "Migrate", "(", "newPaths", "Paths", ")", "{", "if", "newPaths", ".", "DataDir", "!=", "\"", "\"", "{", "p", ".", "DataDir", "=", "newPaths", ".", "DataDir", "\n", "}", "\n", "if", "newPaths", ".", "LogDir", "!=", "\"", "\"", "{", "p", ".", "LogDir", "=", "newPaths", ".", "LogDir", "\n", "}", "\n", "if", "newPaths", ".", "MetricsSpoolDir", "!=", "\"", "\"", "{", "p", ".", "MetricsSpoolDir", "=", "newPaths", ".", "MetricsSpoolDir", "\n", "}", "\n", "if", "newPaths", ".", "ConfDir", "!=", "\"", "\"", "{", "p", ".", "ConfDir", "=", "newPaths", ".", "ConfDir", "\n", "}", "\n", "}" ]

[ "Migrate", "assigns", "the", "directory", "locations", "specified", "from", "the", "new", "path", "configuration", "." ]

[ "func", "NewPathsWithDefaults", "(", "p", "Paths", ")", "Paths", "{", "paths", ":=", "DefaultPaths", "\n", "if", "p", ".", "DataDir", "!=", "\"", "\"", "{", "paths", ".", "DataDir", "=", "p", ".", "DataDir", "\n", "}", "\n", "if", "p", ".", "LogDir", "!=", "\"", "\"", "{", "paths", ".", "LogDir", "=", "p", ".", "LogDir", "\n", "}", "\n", "if", "p", ".", "MetricsSpoolDir", "!=", "\"", "\"", "{", "paths", ".", "MetricsSpoolDir", "=", "p", ".", "MetricsSpoolDir", "\n", "}", "\n", "if", "p", ".", "ConfDir", "!=", "\"", "\"", "{", "paths", ".", "ConfDir", "=", "p", ".", "ConfDir", "\n", "}", "\n", "return", "paths", "\n", "}" ]

[ "NewPathsWithDefaults", "returns", "a", "Paths", "struct", "initialized", "with", "default", "locations", "if", "not", "otherwise", "specified", "." ]

[ "func", "LogFilename", "(", "c", "Config", ")", "string", "{", "return", "filepath", ".", "Join", "(", "c", ".", "LogDir", "(", ")", ",", "c", ".", "Tag", "(", ")", ".", "String", "(", ")", "+", "\"", "\"", ")", "\n", "}" ]

[ "LogFileName", "returns", "the", "filename", "for", "the", "Agent", "s", "log", "file", "." ]

[ "func", "MachineLockLogFilename", "(", "c", "Config", ")", "string", "{", "return", "filepath", ".", "Join", "(", "c", ".", "LogDir", "(", ")", ",", "machinelock", ".", "Filename", ")", "\n", "}" ]

[ "MachineLockLogFilename", "returns", "the", "filename", "for", "the", "machine", "lock", "log", "file", "." ]

[ "func", "NewAgentConfig", "(", "configParams", "AgentConfigParams", ")", "(", "ConfigSetterWriter", ",", "error", ")", "{", "if", "configParams", ".", "Paths", ".", "DataDir", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "configParams", ".", "Tag", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "switch", "configParams", ".", "Tag", ".", "(", "type", ")", "{", "case", "names", ".", "MachineTag", ",", "names", ".", "UnitTag", ",", "names", ".", "ApplicationTag", ":", "// These are the only three type of tags that can represent an agent", "// IAAS - machine and unit", "// CAAS - application", "default", ":", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "configParams", ".", "Tag", ")", "\n", "}", "\n", "if", "configParams", ".", "UpgradedToVersion", "==", "version", ".", "Zero", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "configParams", ".", "Password", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "uuid", ":=", "configParams", ".", "Controller", ".", "Id", "(", ")", ";", "uuid", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "else", "if", "!", "names", ".", "IsValidController", "(", "uuid", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ")", "\n", "}", "\n", "if", "uuid", ":=", "configParams", ".", "Model", ".", "Id", "(", ")", ";", "uuid", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "else", "if", "!", "names", ".", "IsValidModel", "(", "uuid", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ")", "\n", "}", "\n", "if", "len", "(", "configParams", ".", "CACert", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "// Note that the password parts of the state and api information are", "// blank. This is by design: we want to generate a secure password", "// for new agents. So, we create this config without a current password", "// which signals to apicaller worker that it should try to connect using old password.", "// When/if this connection is successful, apicaller worker will generate", "// a new secure password and update this agent's config.", "config", ":=", "&", "configInternal", "{", "paths", ":", "NewPathsWithDefaults", "(", "configParams", ".", "Paths", ")", ",", "jobs", ":", "configParams", ".", "Jobs", ",", "upgradedToVersion", ":", "configParams", ".", "UpgradedToVersion", ",", "tag", ":", "configParams", ".", "Tag", ",", "nonce", ":", "configParams", ".", "Nonce", ",", "controller", ":", "configParams", ".", "Controller", ",", "model", ":", "configParams", ".", "Model", ",", "caCert", ":", "configParams", ".", "CACert", ",", "oldPassword", ":", "configParams", ".", "Password", ",", "values", ":", "configParams", ".", "Values", ",", "mongoVersion", ":", "configParams", ".", "MongoVersion", ".", "String", "(", ")", ",", "mongoMemoryProfile", ":", "configParams", ".", "MongoMemoryProfile", ".", "String", "(", ")", ",", "}", "\n", "if", "len", "(", "configParams", ".", "APIAddresses", ")", ">", "0", "{", "config", ".", "apiDetails", "=", "&", "apiDetails", "{", "addresses", ":", "configParams", ".", "APIAddresses", ",", "}", "\n", "}", "\n", "if", "err", ":=", "config", ".", "check", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "config", ".", "values", "==", "nil", "{", "config", ".", "values", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "config", ".", "configFilePath", "=", "ConfigPath", "(", "config", ".", "paths", ".", "DataDir", ",", "config", ".", "tag", ")", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "NewAgentConfig", "returns", "a", "new", "config", "object", "suitable", "for", "use", "for", "a", "machine", "or", "unit", "agent", "." ]

[ "func", "NewStateMachineConfig", "(", "configParams", "AgentConfigParams", ",", "serverInfo", "params", ".", "StateServingInfo", ")", "(", "ConfigSetterWriter", ",", "error", ")", "{", "if", "serverInfo", ".", "Cert", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "serverInfo", ".", "PrivateKey", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "serverInfo", ".", "CAPrivateKey", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "serverInfo", ".", "StatePort", "==", "0", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "serverInfo", ".", "APIPort", "==", "0", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "requiredError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "config", ",", "err", ":=", "NewAgentConfig", "(", "configParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "config", ".", "SetStateServingInfo", "(", "serverInfo", ")", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "NewStateMachineConfig", "returns", "a", "configuration", "suitable", "for", "a", "machine", "running", "the", "controller", "." ]

[ "func", "Dir", "(", "dataDir", "string", ",", "tag", "names", ".", "Tag", ")", "string", "{", "// Note: must use path, not filepath, as this", "// function is used by the client on Windows.", "return", "path", ".", "Join", "(", "BaseDir", "(", "dataDir", ")", ",", "tag", ".", "String", "(", ")", ")", "\n", "}" ]

[ "Dir", "returns", "the", "agent", "-", "specific", "data", "directory", "." ]

[ "func", "ReadConfig", "(", "configFilePath", "string", ")", "(", "ConfigSetterWriter", ",", "error", ")", "{", "var", "(", "format", "formatter", "\n", "config", "*", "configInternal", "\n", ")", "\n", "configData", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "configFilePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "configFilePath", ")", "\n", "}", "\n", "format", ",", "config", ",", "err", "=", "parseConfigData", "(", "configData", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "format", ".", "version", "(", ")", ")", "\n", "config", ".", "configFilePath", "=", "configFilePath", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "ReadConfig", "reads", "configuration", "data", "from", "the", "given", "location", "." ]

[ "func", "(", "c", "*", "configInternal", ")", "MongoVersion", "(", ")", "mongo", ".", "Version", "{", "v", ",", "err", ":=", "mongo", ".", "NewVersion", "(", "c", ".", "mongoVersion", ")", "\n", "if", "err", "!=", "nil", "{", "return", "mongo", ".", "Mongo24", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "MongoVersion", "implements", "Config", "." ]

[ "func", "(", "c", "*", "configInternal", ")", "MongoMemoryProfile", "(", ")", "mongo", ".", "MemoryProfile", "{", "mprof", ":=", "mongo", ".", "MemoryProfile", "(", "c", ".", "mongoMemoryProfile", ")", "\n", "if", "err", ":=", "mprof", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "mongo", ".", "MemoryProfileLow", "\n", "}", "\n", "return", "mongo", ".", "MemoryProfile", "(", "c", ".", "mongoMemoryProfile", ")", "\n", "}" ]

[ "MongoMemoryProfile", "implements", "Config", "." ]

[ "func", "(", "c", "*", "configInternal", ")", "SetMongoVersion", "(", "v", "mongo", ".", "Version", ")", "{", "c", ".", "mongoVersion", "=", "v", ".", "String", "(", ")", "\n", "}" ]

[ "SetMongoVersion", "implements", "configSetterOnly", "." ]

[ "func", "(", "c", "*", "configInternal", ")", "SetMongoMemoryProfile", "(", "v", "mongo", ".", "MemoryProfile", ")", "{", "c", ".", "mongoMemoryProfile", "=", "v", ".", "String", "(", ")", "\n", "}" ]

[ "SetMongoMemoryProfile", "implements", "configSetterOnly", "." ]

[ "func", "(", "c", "*", "configInternal", ")", "WriteCommands", "(", "renderer", "shell", ".", "Renderer", ")", "(", "[", "]", "string", ",", "error", ")", "{", "data", ",", "err", ":=", "c", ".", "Render", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "commands", ":=", "renderer", ".", "MkdirAll", "(", "c", ".", "Dir", "(", ")", ")", "\n", "filename", ":=", "c", ".", "File", "(", "AgentConfigFilename", ")", "\n", "commands", "=", "append", "(", "commands", ",", "renderer", ".", "WriteFile", "(", "filename", ",", "data", ")", "...", ")", "\n", "commands", "=", "append", "(", "commands", ",", "renderer", ".", "Chmod", "(", "filename", ",", "0600", ")", "...", ")", "\n", "return", "commands", ",", "nil", "\n", "}" ]

[ "WriteCommands", "is", "defined", "on", "Config", "interface", "." ]

[ "func", "(", "c", "*", "configInternal", ")", "APIInfo", "(", ")", "(", "*", "api", ".", "Info", ",", "bool", ")", "{", "if", "c", ".", "apiDetails", "==", "nil", "||", "c", ".", "apiDetails", ".", "addresses", "==", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n", "servingInfo", ",", "isController", ":=", "c", ".", "StateServingInfo", "(", ")", "\n", "addrs", ":=", "c", ".", "apiDetails", ".", "addresses", "\n", "// For controller we return only localhost - we should not connect", "// to other controllers if we can talk locally.", "if", "isController", "{", "port", ":=", "servingInfo", ".", "APIPort", "\n", "// If the controller has been configured with a controller api port,", "// we return that instead of the normal api port.", "if", "servingInfo", ".", "ControllerAPIPort", "!=", "0", "{", "port", "=", "servingInfo", ".", "ControllerAPIPort", "\n", "}", "\n", "// TODO(macgreagoir) IPv6. Ubuntu still always provides IPv4", "// loopback, and when/if this changes localhost should resolve", "// to IPv6 loopback in any case (lp:1644009). Review.", "localAPIAddr", ":=", "net", ".", "JoinHostPort", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "port", ")", ")", "\n", "addrs", "=", "[", "]", "string", "{", "localAPIAddr", "}", "\n", "}", "\n", "return", "&", "api", ".", "Info", "{", "Addrs", ":", "addrs", ",", "Password", ":", "c", ".", "apiDetails", ".", "password", ",", "CACert", ":", "c", ".", "caCert", ",", "Tag", ":", "c", ".", "tag", ",", "Nonce", ":", "c", ".", "nonce", ",", "ModelTag", ":", "c", ".", "model", ",", "}", ",", "true", "\n", "}" ]

[ "APIInfo", "is", "defined", "on", "Config", "interface", "." ]

[ "func", "(", "c", "*", "configInternal", ")", "MongoInfo", "(", ")", "(", "info", "*", "mongo", ".", "MongoInfo", ",", "ok", "bool", ")", "{", "ssi", ",", "ok", ":=", "c", ".", "StateServingInfo", "(", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "false", "\n", "}", "\n", "// We return localhost first and then all addresses of known API", "// endpoints - this lets us connect to other Mongo instances and start", "// state even if our own Mongo has not started yet (see lp:1749383 #1).", "// TODO(macgreagoir) IPv6. Ubuntu still always provides IPv4 loopback,", "// and when/if this changes localhost should resolve to IPv6 loopback", "// in any case (lp:1644009). Review.", "local", ":=", "net", ".", "JoinHostPort", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "ssi", ".", "StatePort", ")", ")", "\n", "addrs", ":=", "[", "]", "string", "{", "local", "}", "\n\n", "for", "_", ",", "addr", ":=", "range", "c", ".", "apiDetails", ".", "addresses", "{", "host", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n", "if", "host", ":=", "net", ".", "JoinHostPort", "(", "host", ",", "strconv", ".", "Itoa", "(", "ssi", ".", "StatePort", ")", ")", ";", "host", "!=", "local", "{", "addrs", "=", "append", "(", "addrs", ",", "host", ")", "\n", "}", "\n", "}", "\n", "return", "&", "mongo", ".", "MongoInfo", "{", "Info", ":", "mongo", ".", "Info", "{", "Addrs", ":", "addrs", ",", "CACert", ":", "c", ".", "caCert", ",", "}", ",", "Password", ":", "c", ".", "statePassword", ",", "Tag", ":", "c", ".", "tag", ",", "}", ",", "true", "\n", "}" ]

[ "MongoInfo", "is", "defined", "on", "Config", "interface", "." ]

[ "func", "isCAASModelFacade", "(", "facadeName", "string", ")", "bool", "{", "return", "caasModelFacadeNames", ".", "Contains", "(", "facadeName", ")", "||", "commonModelFacadeNames", ".", "Contains", "(", "facadeName", ")", "||", "commonFacadeNames", ".", "Contains", "(", "facadeName", ")", "\n", "}" ]

[ "isCAASModelFacade", "reports", "whether", "the", "given", "facade", "name", "can", "be", "accessed", "using", "the", "controller", "connection", "." ]

[ "func", "(", "e", "*", "TermsRequiredError", ")", "UserErr", "(", ")", "error", "{", "terms", ":=", "strings", ".", "Join", "(", "e", ".", "Terms", ",", "\"", "\"", ")", "\n", "return", "errors", ".", "Wrap", "(", "e", ",", "errors", ".", "Errorf", "(", "`Declined: some terms require agreement. Try: \"juju agree %s\"`", ",", "terms", ")", ")", "\n", "}" ]

[ "UserErr", "returns", "an", "error", "containing", "a", "user", "-", "friendly", "message", "describing", "how", "to", "agree", "to", "required", "terms", "." ]

[ "func", "(", "ic", "*", "InstanceConstraint", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ic", ".", "Region", ",", "ic", ".", "Series", ",", "ic", ".", "Arches", ",", "ic", ".", "Constraints", ",", "ic", ".", "Storage", ",", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "readable", "form", "of", "this", "InstanceConstraint", "." ]

[ "func", "(", "image", "Image", ")", "match", "(", "itype", "InstanceType", ")", "imageMatch", "{", "if", "!", "image", ".", "matchArch", "(", "itype", ".", "Arches", ")", "{", "return", "nonMatch", "\n", "}", "\n", "if", "itype", ".", "VirtType", "==", "nil", "||", "image", ".", "VirtType", "==", "*", "itype", ".", "VirtType", "{", "return", "exactMatch", "\n", "}", "\n", "if", "image", ".", "VirtType", "==", "\"", "\"", "{", "// Image doesn't specify virtualisation type. We allow it", "// to match, but prefer exact matches.", "return", "partialMatch", "\n", "}", "\n", "return", "nonMatch", "\n", "}" ]

[ "match", "returns", "true", "if", "the", "image", "can", "run", "on", "the", "supplied", "instance", "type", "." ]

[ "func", "New", "(", "externalControllers", "ExternalControllerUpdaterClient", ",", "newExternalControllerWatcherClient", "NewExternalControllerWatcherClientFunc", ",", "clock", "clock", ".", "Clock", ",", ")", "(", "worker", ".", "Worker", ",", "error", ")", "{", "w", ":=", "updaterWorker", "{", "watchExternalControllers", ":", "externalControllers", ".", "WatchExternalControllers", ",", "externalControllerInfo", ":", "externalControllers", ".", "ExternalControllerInfo", ",", "setExternalControllerInfo", ":", "externalControllers", ".", "SetExternalControllerInfo", ",", "newExternalControllerWatcherClient", ":", "newExternalControllerWatcherClient", ",", "runner", ":", "worker", ".", "NewRunner", "(", "worker", ".", "RunnerParams", "{", "// One of the controller watchers fails should not", "// prevent the others from running.", "IsFatal", ":", "func", "(", "error", ")", "bool", "{", "return", "false", "}", ",", "// If the API connection fails, try again in 1 minute.", "RestartDelay", ":", "time", ".", "Minute", ",", "Clock", ":", "clock", ",", "}", ")", ",", "}", "\n", "if", "err", ":=", "catacomb", ".", "Invoke", "(", "catacomb", ".", "Plan", "{", "Site", ":", "&", "w", ".", "catacomb", ",", "Work", ":", "w", ".", "loop", ",", "Init", ":", "[", "]", "worker", ".", "Worker", "{", "w", ".", "runner", "}", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "&", "w", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "new", "external", "controller", "updater", "worker", "." ]

[ "func", "NewMockAvailabilityZone", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockAvailabilityZone", "{", "mock", ":=", "&", "MockAvailabilityZone", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockAvailabilityZoneMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

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

[ "Available", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockAvailabilityZoneMockRecorder", ")", "Available", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockAvailabilityZone", ")", "(", "nil", ")", ".", "Available", ")", ")", "\n", "}" ]

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

[ "func", "NewMockMetricsCollector", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockMetricsCollector", "{", "mock", ":=", "&", "MockMetricsCollector", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockMetricsCollectorMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockMetricsCollector", ")", "Connections", "(", ")", "prometheus", ".", "Gauge", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "prometheus", ".", "Gauge", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Connections", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockMetricsCollector", ")", "LogReadCount", "(", "arg0", ",", "arg1", "string", ")", "prometheus", ".", "Counter", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "prometheus", ".", "Counter", ")", "\n", "return", "ret0", "\n", "}" ]

[ "LogReadCount", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockMetricsCollectorMockRecorder", ")", "LogReadCount", "(", "arg0", ",", "arg1", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockMetricsCollector", ")", "(", "nil", ")", ".", "LogReadCount", ")", ",", "arg0", ",", "arg1", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockMetricsCollector", ")", "PingFailureCount", "(", "arg0", "string", ")", "prometheus", ".", "Counter", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "prometheus", ".", "Counter", ")", "\n", "return", "ret0", "\n", "}" ]

[ "PingFailureCount", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockMetricsCollector", ")", "TotalConnections", "(", ")", "prometheus", ".", "Counter", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "prometheus", ".", "Counter", ")", "\n", "return", "ret0", "\n", "}" ]

[ "TotalConnections", "mocks", "base", "method" ]

[ "func", "NewFacade", "(", "apiCaller", "base", ".", "APICaller", ")", "(", "Facade", ",", "error", ")", "{", "return", "applicationscaler", ".", "NewAPI", "(", "apiCaller", ",", "watcher", ".", "NewStringsWatcher", ",", ")", ",", "nil", "\n", "}" ]

[ "NewFacade", "creates", "a", "Facade", "from", "a", "base", ".", "APICaller", ".", "It", "s", "a", "sensible", "value", "for", "ManifoldConfig", ".", "NewFacade", "." ]

[ "func", "(", "l", "*", "streamLayer", ")", "Close", "(", ")", "error", "{", "l", ".", "tomb", ".", "Kill", "(", "nil", ")", "\n", "return", "l", ".", "tomb", ".", "Wait", "(", ")", "\n", "}" ]

[ "Close", "closes", "the", "layer", "." ]

[ "func", "(", "l", "*", "streamLayer", ")", "Addr", "(", ")", "net", ".", "Addr", "{", "select", "{", "case", "<-", "l", ".", "tomb", ".", "Dying", "(", ")", ":", "return", "invalidAddr", "\n", "case", "<-", "l", ".", "clock", ".", "After", "(", "AddrTimeout", ")", ":", "logger", ".", "Errorf", "(", "\"", "\"", ")", "\n", "// Stop this (and parent) worker.", "l", ".", "tomb", ".", "Kill", "(", "ErrAddressTimeout", ")", "\n", "return", "invalidAddr", "\n", "case", "addr", ":=", "<-", "l", ".", "addr", ":", "return", "addr", "\n", "}", "\n", "}" ]

[ "Addr", "returns", "the", "local", "address", "for", "the", "layer", "." ]

[ "func", "(", "r", "resources", ")", "registerForServer", "(", ")", "error", "{", "r", ".", "registerState", "(", ")", "\n", "r", ".", "registerAgentWorkers", "(", ")", "\n", "r", ".", "registerHookContext", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "RegisterForServer", "is", "the", "top", "-", "level", "registration", "method", "for", "the", "component", "in", "a", "jujud", "context", "." ]

[ "func", "(", "r", "resources", ")", "registerAgentWorkers", "(", ")", "{", "if", "!", "markRegistered", "(", "resource", ".", "ComponentName", ",", "\"", "\"", ")", "{", "return", "\n", "}", "\n\n", "charmrevisionupdater", ".", "RegisterLatestCharmHandler", "(", "\"", "\"", ",", "resourceadapters", ".", "NewLatestCharmHandler", ")", "\n", "}" ]

[ "registerAgentWorkers", "adds", "the", "resources", "workers", "to", "the", "agents", "." ]

[ "func", "NewMockZonedEnviron", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockZonedEnviron", "{", "mock", ":=", "&", "MockZonedEnviron", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockZonedEnvironMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "AdoptResources", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "string", ",", "arg2", "version", ".", "Number", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ",", "arg2", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "AdoptResources", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "AvailabilityZones", "(", "arg0", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "common", ".", "AvailabilityZone", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "common", ".", "AvailabilityZone", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "AvailabilityZones", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "ConstraintsValidator", "(", "arg0", "context", ".", "ProviderCallContext", ")", "(", "constraints", ".", "Validator", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "constraints", ".", "Validator", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "ConstraintsValidator", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "DeriveAvailabilityZones", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "environs", ".", "StartInstanceParams", ")", "(", "[", "]", "string", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "string", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "DeriveAvailabilityZones", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "Destroy", "(", "arg0", "context", ".", "ProviderCallContext", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Destroy", "mocks", "base", "method" ]