func (s *MigrationExportSuite) TestFilesystems(c *gc.C) {
machine := s.Factory.MakeMachine(c, &factory.MachineParams{
Filesystems: []state.MachineFilesystemParams{{
Filesystem: state.FilesystemParams{Size: 1234},
Attachment: state.FilesystemAttachmentParams{
Location: "location",
ReadOnly: true},
}, {
Filesystem: state.FilesystemParams{Size: 4000},
}},
})
machineTag := machine.MachineTag()
// We know that the first filesystem is called "0/0" as it is the first
// filesystem (filesystems use sequences), and it is bound to machine 0.
fsTag := names.NewFilesystemTag("0/0")
err := s.State.SetFilesystemInfo(fsTag, state.FilesystemInfo{
Size: 1500,
FilesystemId: "filesystem id",
})
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetFilesystemAttachmentInfo(machineTag, fsTag, state.FilesystemAttachmentInfo{
MountPoint: "/mnt/foo",
ReadOnly: true,
})
c.Assert(err, jc.ErrorIsNil)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
filesystems := model.Filesystems()
c.Assert(filesystems, gc.HasLen, 2)
provisioned, notProvisioned := filesystems[0], filesystems[1]
c.Check(provisioned.Tag(), gc.Equals, fsTag)
c.Check(provisioned.Volume(), gc.Equals, names.VolumeTag{})
c.Check(provisioned.Storage(), gc.Equals, names.StorageTag{})
binding, err := provisioned.Binding()
c.Check(err, jc.ErrorIsNil)
c.Check(binding, gc.Equals, machineTag)
c.Check(provisioned.Provisioned(), jc.IsTrue)
c.Check(provisioned.Size(), gc.Equals, uint64(1500))
c.Check(provisioned.Pool(), gc.Equals, "rootfs")
c.Check(provisioned.FilesystemID(), gc.Equals, "filesystem id")
attachments := provisioned.Attachments()
c.Assert(attachments, gc.HasLen, 1)
attachment := attachments[0]
c.Check(attachment.Machine(), gc.Equals, machineTag)
c.Check(attachment.Provisioned(), jc.IsTrue)
c.Check(attachment.ReadOnly(), jc.IsTrue)
c.Check(attachment.MountPoint(), gc.Equals, "/mnt/foo")
c.Check(notProvisioned.Tag(), gc.Equals, names.NewFilesystemTag("0/1"))
c.Check(notProvisioned.Volume(), gc.Equals, names.VolumeTag{})
c.Check(notProvisioned.Storage(), gc.Equals, names.StorageTag{})
binding, err = notProvisioned.Binding()
c.Check(err, jc.ErrorIsNil)
c.Check(binding, gc.Equals, machineTag)
c.Check(notProvisioned.Provisioned(), jc.IsFalse)
c.Check(notProvisioned.Size(), gc.Equals, uint64(4000))
c.Check(notProvisioned.Pool(), gc.Equals, "rootfs")
c.Check(notProvisioned.FilesystemID(), gc.Equals, "")
attachments = notProvisioned.Attachments()
c.Assert(attachments, gc.HasLen, 1)
attachment = attachments[0]
c.Check(attachment.Machine(), gc.Equals, machineTag)
c.Check(attachment.Provisioned(), jc.IsFalse)
c.Check(attachment.ReadOnly(), jc.IsFalse)
c.Check(attachment.MountPoint(), gc.Equals, "")
// Make sure there is a status.
status := provisioned.Status()
c.Check(status.Value(), gc.Equals, "pending")
}
func (s *MigrationExportSuite) TestVolumes(c *gc.C) {
machine := s.Factory.MakeMachine(c, &factory.MachineParams{
Volumes: []state.MachineVolumeParams{{
Volume: state.VolumeParams{Size: 1234},
Attachment: state.VolumeAttachmentParams{ReadOnly: true},
}, {
Volume: state.VolumeParams{Size: 4000},
}},
})
machineTag := machine.MachineTag()
// We know that the first volume is called "0/0" as it is the first volume
// (volumes use sequences), and it is bound to machine 0.
volTag := names.NewVolumeTag("0/0")
err := s.State.SetVolumeInfo(volTag, state.VolumeInfo{
HardwareId: "magic",
Size: 1500,
VolumeId: "volume id",
Persistent: true,
})
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetVolumeAttachmentInfo(machineTag, volTag, state.VolumeAttachmentInfo{
DeviceName: "device name",
DeviceLink: "device link",
BusAddress: "bus address",
ReadOnly: true,
})
c.Assert(err, jc.ErrorIsNil)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
volumes := model.Volumes()
c.Assert(volumes, gc.HasLen, 2)
provisioned, notProvisioned := volumes[0], volumes[1]
c.Check(provisioned.Tag(), gc.Equals, volTag)
binding, err := provisioned.Binding()
c.Check(err, jc.ErrorIsNil)
c.Check(binding, gc.Equals, machineTag)
c.Check(provisioned.Provisioned(), jc.IsTrue)
c.Check(provisioned.Size(), gc.Equals, uint64(1500))
c.Check(provisioned.Pool(), gc.Equals, "loop")
c.Check(provisioned.HardwareID(), gc.Equals, "magic")
c.Check(provisioned.VolumeID(), gc.Equals, "volume id")
c.Check(provisioned.Persistent(), jc.IsTrue)
attachments := provisioned.Attachments()
c.Assert(attachments, gc.HasLen, 1)
attachment := attachments[0]
c.Check(attachment.Machine(), gc.Equals, machineTag)
c.Check(attachment.Provisioned(), jc.IsTrue)
c.Check(attachment.ReadOnly(), jc.IsTrue)
c.Check(attachment.DeviceName(), gc.Equals, "device name")
c.Check(attachment.DeviceLink(), gc.Equals, "device link")
c.Check(attachment.BusAddress(), gc.Equals, "bus address")
c.Check(notProvisioned.Tag(), gc.Equals, names.NewVolumeTag("0/1"))
binding, err = notProvisioned.Binding()
c.Check(err, jc.ErrorIsNil)
c.Check(binding, gc.Equals, machineTag)
c.Check(notProvisioned.Provisioned(), jc.IsFalse)
c.Check(notProvisioned.Size(), gc.Equals, uint64(4000))
c.Check(notProvisioned.Pool(), gc.Equals, "loop")
c.Check(notProvisioned.HardwareID(), gc.Equals, "")
c.Check(notProvisioned.VolumeID(), gc.Equals, "")
c.Check(notProvisioned.Persistent(), jc.IsFalse)
attachments = notProvisioned.Attachments()
c.Assert(attachments, gc.HasLen, 1)
attachment = attachments[0]
c.Check(attachment.Machine(), gc.Equals, machineTag)
c.Check(attachment.Provisioned(), jc.IsFalse)
c.Check(attachment.ReadOnly(), jc.IsFalse)
c.Check(attachment.DeviceName(), gc.Equals, "")
c.Check(attachment.DeviceLink(), gc.Equals, "")
c.Check(attachment.BusAddress(), gc.Equals, "")
// Make sure there is a status.
status := provisioned.Status()
c.Check(status.Value(), gc.Equals, "pending")
}