func (s *ebsVolumeSuite) assertCreateVolumes(c *gc.C, vs storage.VolumeSource, instanceId string) {
vols, err := s.createVolumes(vs, instanceId)
c.Assert(err, jc.ErrorIsNil)
c.Assert(vols, gc.HasLen, 3)
c.Assert(vols, jc.SameContents, []storage.Volume{{
names.NewVolumeTag("0"),
storage.VolumeInfo{
Size: 10240,
VolumeId: "vol-0",
Persistent: true,
},
}, {
names.NewVolumeTag("1"),
storage.VolumeInfo{
Size: 20480,
VolumeId: "vol-1",
Persistent: true,
},
}, {
names.NewVolumeTag("2"),
storage.VolumeInfo{
Size: 30720,
VolumeId: "vol-2",
Persistent: false,
},
}})
ec2Client := ec2.StorageEC2(vs)
ec2Vols, err := ec2Client.Volumes(nil, nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ec2Vols.Volumes, gc.HasLen, 3)
sortBySize(ec2Vols.Volumes)
c.Assert(ec2Vols.Volumes[0].Size, gc.Equals, 10)
c.Assert(ec2Vols.Volumes[1].Size, gc.Equals, 20)
c.Assert(ec2Vols.Volumes[2].Size, gc.Equals, 30)
}
func (s *ebsVolumeSuite) TestDestroyVolumesStillAttached(c *gc.C) {
vs := s.volumeSource(c, nil)
s.setupAttachVolumesTest(c, vs, ec2test.Running)
errs := vs.DestroyVolumes([]string{"vol-0"})
c.Assert(errs, jc.DeepEquals, []error{nil})
ec2Client := ec2.StorageEC2(vs)
ec2Vols, err := ec2Client.Volumes(nil, nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ec2Vols.Volumes, gc.HasLen, 2)
sortBySize(ec2Vols.Volumes)
c.Assert(ec2Vols.Volumes[0].Size, gc.Equals, 20)
}
func (s *ebsVolumeSuite) TestVolumeTags(c *gc.C) {
vs := s.volumeSource(c, nil)
results, err := s.createVolumes(vs, "")
c.Assert(err, jc.ErrorIsNil)
c.Assert(results, gc.HasLen, 3)
c.Assert(results[0].Error, jc.ErrorIsNil)
c.Assert(results[0].Volume, jc.DeepEquals, &storage.Volume{
names.NewVolumeTag("0"),
storage.VolumeInfo{
Size: 10240,
VolumeId: "vol-0",
Persistent: true,
},
})
c.Assert(results[1].Error, jc.ErrorIsNil)
c.Assert(results[1].Volume, jc.DeepEquals, &storage.Volume{
names.NewVolumeTag("1"),
storage.VolumeInfo{
Size: 20480,
VolumeId: "vol-1",
Persistent: true,
},
})
c.Assert(results[2].Error, jc.ErrorIsNil)
c.Assert(results[2].Volume, jc.DeepEquals, &storage.Volume{
names.NewVolumeTag("2"),
storage.VolumeInfo{
Size: 30720,
VolumeId: "vol-2",
Persistent: true,
},
})
ec2Client := ec2.StorageEC2(vs)
ec2Vols, err := ec2Client.Volumes(nil, nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ec2Vols.Volumes, gc.HasLen, 3)
sortBySize(ec2Vols.Volumes)
c.Assert(ec2Vols.Volumes[0].Tags, jc.SameContents, []awsec2.Tag{
{"juju-env-uuid", "deadbeef-0bad-400d-8000-4b1d0d06f00d"},
{"Name", "juju-sample-volume-0"},
})
c.Assert(ec2Vols.Volumes[1].Tags, jc.SameContents, []awsec2.Tag{
{"juju-env-uuid", "something-else"},
{"Name", "juju-sample-volume-1"},
})
c.Assert(ec2Vols.Volumes[2].Tags, jc.SameContents, []awsec2.Tag{
{"Name", "juju-sample-volume-2"},
{"abc", "123"},
})
}
func (s *ebsVolumeSuite) TestDetachVolumes(c *gc.C) {
vs := s.volumeSource(c, nil)
params := s.setupAttachVolumesTest(c, vs, ec2test.Running)
_, err := vs.AttachVolumes(params)
c.Assert(err, jc.ErrorIsNil)
err = vs.DetachVolumes(params)
c.Assert(err, jc.ErrorIsNil)
ec2Client := ec2.StorageEC2(vs)
ec2Vols, err := ec2Client.Volumes(nil, nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ec2Vols.Volumes, gc.HasLen, 3)
sortBySize(ec2Vols.Volumes)
c.Assert(ec2Vols.Volumes[0].Attachments, gc.HasLen, 0)
// Test idempotent
err = vs.DetachVolumes(params)
c.Assert(err, jc.ErrorIsNil)
}
func (s *ebsVolumeSuite) TestVolumeTags(c *gc.C) {
vs := s.volumeSource(c, nil)
vols, err := s.createVolumes(vs, "")
c.Assert(err, jc.ErrorIsNil)
c.Assert(vols, gc.HasLen, 3)
c.Assert(vols, jc.SameContents, []storage.Volume{{
names.NewVolumeTag("0"),
storage.VolumeInfo{
Size: 10240,
VolumeId: "vol-0",
Persistent: true,
},
}, {
names.NewVolumeTag("1"),
storage.VolumeInfo{
Size: 20480,
VolumeId: "vol-1",
Persistent: true,
},
}, {
names.NewVolumeTag("2"),
storage.VolumeInfo{
Size: 30720,
VolumeId: "vol-2",
Persistent: false,
},
}})
ec2Client := ec2.StorageEC2(vs)
ec2Vols, err := ec2Client.Volumes(nil, nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ec2Vols.Volumes, gc.HasLen, 3)
sortBySize(ec2Vols.Volumes)
c.Assert(ec2Vols.Volumes[0].Tags, jc.SameContents, []awsec2.Tag{
{"Name", "juju-sample-volume-0"},
})
c.Assert(ec2Vols.Volumes[1].Tags, jc.SameContents, []awsec2.Tag{
{"Name", "juju-sample-volume-1"},
})
c.Assert(ec2Vols.Volumes[2].Tags, jc.SameContents, []awsec2.Tag{
{"Name", "juju-sample-volume-2"},
{"abc", "123"},
})
}
func (s *ebsVolumeSuite) TestAttachVolumes(c *gc.C) {
vs := s.volumeSource(c, nil)
params := s.setupAttachVolumesTest(c, vs, ec2test.Running)
result, err := vs.AttachVolumes(params)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.HasLen, 1)
c.Assert(result[0].Error, jc.ErrorIsNil)
c.Assert(result[0].VolumeAttachment, jc.DeepEquals, &storage.VolumeAttachment{
names.NewVolumeTag("0"),
names.NewMachineTag("1"),
storage.VolumeAttachmentInfo{
DeviceName: "xvdf",
ReadOnly: false,
},
})
ec2Client := ec2.StorageEC2(vs)
ec2Vols, err := ec2Client.Volumes(nil, nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ec2Vols.Volumes, gc.HasLen, 3)
sortBySize(ec2Vols.Volumes)
c.Assert(ec2Vols.Volumes[0].Attachments, jc.DeepEquals, []awsec2.VolumeAttachment{{
VolumeId: "vol-0",
InstanceId: "i-3",
Device: "/dev/sdf",
Status: "attached",
}})
// Test idempotency.
result, err = vs.AttachVolumes(params)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.HasLen, 1)
c.Assert(result[0].Error, jc.ErrorIsNil)
c.Assert(result[0].VolumeAttachment, jc.DeepEquals, &storage.VolumeAttachment{
names.NewVolumeTag("0"),
names.NewMachineTag("1"),
storage.VolumeAttachmentInfo{
DeviceName: "xvdf",
ReadOnly: false,
},
})
}
func (s *ebsVolumeSuite) TestVolumeTypeAliases(c *gc.C) {
instanceIdRunning := s.srv.ec2srv.NewInstances(1, "m1.medium", imageId, ec2test.Running, nil)[0]
vs := s.volumeSource(c, nil)
ec2Client := ec2.StorageEC2(vs)
aliases := [][2]string{
{"magnetic", "standard"},
{"ssd", "gp2"},
{"provisioned-iops", "io1"},
}
for i, alias := range aliases {
params := []storage.VolumeParams{{
Tag: names.NewVolumeTag("0"),
Size: 10 * 1000,
Provider: ec2.EBS_ProviderType,
Attributes: map[string]interface{}{
"volume-type": alias[0],
},
Attachment: &storage.VolumeAttachmentParams{
AttachmentParams: storage.AttachmentParams{
InstanceId: instance.Id(instanceIdRunning),
},
},
}}
if alias[1] == "io1" {
params[0].Attributes["iops"] = 30
}
results, err := vs.CreateVolumes(params)
c.Assert(err, jc.ErrorIsNil)
c.Assert(results, gc.HasLen, 1)
c.Assert(results[0].Error, jc.ErrorIsNil)
c.Assert(results[0].Volume.VolumeId, gc.Equals, fmt.Sprintf("vol-%d", i))
}
ec2Vols, err := ec2Client.Volumes(nil, nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ec2Vols.Volumes, gc.HasLen, len(aliases))
sort.Sort(volumeSorter{ec2Vols.Volumes, func(i, j awsec2.Volume) bool {
return i.Id < j.Id
}})
for i, alias := range aliases {
c.Assert(ec2Vols.Volumes[i].VolumeType, gc.Equals, alias[1])
}
}