// Test volume retrieval by volume name using Volumes, which retrieves all volumes
// from the storage driver without filtering, and filters the volumes externally.
func volumeByName(
t *testing.T, client types.Client, volumeName, tag string) *types.Volume {
log.WithField("volumeName", volumeName).Info("get volume by ebs.Name")
// Retrieve all volumes
vols, err := client.API().Volumes(nil, 0)
assert.NoError(t, err)
if err != nil {
t.FailNow()
}
// If tag is set, then add tag to expected volumeName
if tag != "" {
volumeName = tag + ebs.TagDelimiter + volumeName
}
// Filter volumes to those under the ec2 service,
// and find a volume matching inputted volume name
assert.Contains(t, vols, ebs.Name)
for _, vol := range vols[ebs.Name] {
if vol.Name == volumeName {
return vol
}
}
// No matching volumes found
t.FailNow()
t.Error("failed volumeByName")
return nil
}
func volumeCopy(
t *testing.T, client types.Client,
volumeID, volumeName string) *types.Volume {
fields := map[string]interface{}{
"volumeID": volumeID,
"volumeName": volumeName,
}
log.WithFields(fields).Info("copying volume")
volumeCopyRequest := &types.VolumeCopyRequest{
VolumeName: volumeName,
}
reply, err := client.API().VolumeCopy(nil,
rackspace.Name, volumeID, volumeCopyRequest)
assert.NoError(t, err)
if err != nil {
t.FailNow()
t.Error("failed volumeCopy")
}
apitests.LogAsJSON(reply, t)
assert.Equal(t, volumeName, reply.Name)
return reply
}
// Test volume attachment by volume ID
func volumeAttach(
t *testing.T, client types.Client, volumeID string) *types.Volume {
log.WithField("volumeID", volumeID).Info("attaching volume")
// Get next device name from executor
nextDevice, err := client.Executor().NextDevice(context.Background().WithValue(context.ServiceKey, ebs.Name),
utils.NewStore())
assert.NoError(t, err)
if err != nil {
t.Error("error getting next device name from executor")
t.FailNow()
}
reply, token, err := client.API().VolumeAttach(
nil, ebs.Name, volumeID, &types.VolumeAttachRequest{
NextDeviceName: &nextDevice,
})
assert.NoError(t, err)
if err != nil {
t.Error("failed volumeAttach")
t.FailNow()
}
apitests.LogAsJSON(reply, t)
assert.NotEqual(t, token, "")
return reply
}
func volumeCreate(
t *testing.T, client types.Client, volumeName string) *types.Volume {
log.WithField("volumeName", volumeName).Info("creating volume")
size := int64(8)
opts := map[string]interface{}{
"priority": 2,
"owner": "*****@*****.**",
}
volumeCreateRequest := &types.VolumeCreateRequest{
Name: volumeName,
Size: &size,
Opts: opts,
}
reply, err := client.API().VolumeCreate(nil, rackspace.Name, volumeCreateRequest)
assert.NoError(t, err)
if err != nil {
t.FailNow()
t.Error("failed volumeCreate")
}
apitests.LogAsJSON(reply, t)
assert.Equal(t, volumeName, reply.Name)
assert.Equal(t, int64(75), reply.Size)
return reply
}
func volumeSnapshot(
t *testing.T, client types.Client,
volumeID, snapshotName string) *types.Snapshot {
log.WithField("snapshotName", snapshotName).Info("creating snapshot")
/*
opts := map[string]interface{}{
"priority": 2,
"owner": "*****@*****.**",
}*/
volumeSnapshotRequest := &types.VolumeSnapshotRequest{
SnapshotName: snapshotName,
// Opts: opts,
}
reply, err := client.API().VolumeSnapshot(nil, rackspace.Name,
volumeID, volumeSnapshotRequest)
assert.NoError(t, err)
if err != nil {
t.FailNow()
t.Error("failed snapshotCreate")
}
apitests.LogAsJSON(reply, t)
assert.Equal(t, snapshotName, reply.Name)
assert.Equal(t, volumeID, reply.VolumeID)
return reply
}
///////////////////////////////////////////////////////////////////////
///////// PRIVATE TESTS FOR VOLUME FUNCTIONALITY /////////
///////////////////////////////////////////////////////////////////////
// Test volume creation specifying size and volume name
func volumeCreate(
t *testing.T, client types.Client, volumeName, tag string) *types.Volume {
log.WithField("volumeName", volumeName).Info("creating volume")
// Prepare request for storage driver call to create volume
size := int64(1)
opts := map[string]interface{}{
"priority": 2,
"owner": "*****@*****.**",
}
volumeCreateRequest := &types.VolumeCreateRequest{
Name: volumeName,
Size: &size,
Opts: opts,
}
// Send request and retrieve created libStorage types.Volume
reply, err := client.API().VolumeCreate(nil, ebs.Name, volumeCreateRequest)
assert.NoError(t, err)
if err != nil {
t.FailNow()
t.Error("failed volumeCreate")
}
apitests.LogAsJSON(reply, t)
// If tag is set, then add tag to expected volumeName
if tag != "" {
volumeName = tag + ebs.TagDelimiter + volumeName
}
// Check if name and size are same
assert.Equal(t, volumeName, reply.Name)
assert.Equal(t, size, reply.Size)
return reply
}
func volumeRemove(t *testing.T, client types.Client, volumeID string) {
log.WithField("volumeID", volumeID).Info("removing volume")
err := client.API().VolumeRemove(
nil, rackspace.Name, volumeID)
assert.NoError(t, err)
if err != nil {
t.Error("failed volumeRemove")
t.FailNow()
}
}
func snapshotRemove(t *testing.T, client types.Client, snapshotID string) {
log.WithField("snapshotID", snapshotID).Info("removing snapshot")
err := client.API().SnapshotRemove(
nil, rackspace.Name, snapshotID)
assert.NoError(t, err)
if err != nil {
t.Error("failed snapshotRemove")
t.FailNow()
}
}
// Test volume retrieval by volume ID using VolumeInspect, which directly
// retrieves matching volumes from the storage driver. Contrast with
// volumeByID, which uses Volumes to retrieve all volumes from the storage
// driver without filtering, and filters the volumes externally.
func volumeInspect(
t *testing.T, client types.Client, volumeID string) *types.Volume {
log.WithField("volumeID", volumeID).Info("inspecting volume")
reply, err := client.API().VolumeInspect(nil, ebs.Name, volumeID, 0)
assert.NoError(t, err)
if err != nil {
t.Error("failed volumeInspect")
t.FailNow()
}
apitests.LogAsJSON(reply, t)
return reply
}
func snapshotInspect(
t *testing.T, client types.Client, snapshotID string) *types.Snapshot {
log.WithField("snapshotID", snapshotID).Info("inspecting snapshot")
reply, err := client.API().SnapshotInspect(nil, rackspace.Name, snapshotID)
assert.NoError(t, err)
if err != nil {
t.Error("failed snapshotInspect")
t.FailNow()
}
apitests.LogAsJSON(reply, t)
return reply
}
// Test detaching volume by volume ID
func volumeDetach(
t *testing.T, client types.Client, volumeID string) *types.Volume {
log.WithField("volumeID", volumeID).Info("detaching volume")
reply, err := client.API().VolumeDetach(
nil, ebs.Name, volumeID, &types.VolumeDetachRequest{})
assert.NoError(t, err)
if err != nil {
t.Error("failed volumeDetach")
t.FailNow()
}
apitests.LogAsJSON(reply, t)
assert.Len(t, reply.Attachments, 0)
return reply
}
func volumeInspectDetachedFail(
t *testing.T, client types.Client, volumeID string) *types.Volume {
log.WithField("volumeID", volumeID).Info("inspecting volume")
reply, err := client.API().VolumeInspect(nil, rackspace.Name, volumeID, 0)
assert.NoError(t, err)
if err != nil {
t.Error("failed volumeInspectDetachedFail")
t.FailNow()
}
apitests.LogAsJSON(reply, t)
assert.Len(t, reply.Attachments, 1)
apitests.LogAsJSON(reply, t)
return reply
}
func volumeAttach(
t *testing.T, client types.Client, volumeID string) *types.Volume {
log.WithField("volumeID", volumeID).Info("attaching volume")
reply, token, err := client.API().VolumeAttach(
nil, rackspace.Name, volumeID, &types.VolumeAttachRequest{})
assert.NoError(t, err)
if err != nil {
t.Error("failed volumeAttach")
t.FailNow()
}
apitests.LogAsJSON(reply, t)
assert.NotEqual(t, token, "")
return reply
}
func volumeInspectAttached(
t *testing.T, client types.Client, volumeID string) *types.Volume {
log.WithField("volumeID", volumeID).Info("inspecting volume")
reply, err := client.API().VolumeInspect(
nil, isilon.Name, volumeID, types.VolAttReqTrue)
assert.NoError(t, err)
if err != nil {
t.Error("failed volumeInspectAttached")
t.FailNow()
}
apitests.LogAsJSON(reply, t)
assert.Len(t, reply.Attachments, 1)
// assert.NotEqual(t, "", reply.Attachments[0].DeviceName)
return reply
}
func snapshotByName(
t *testing.T, client types.Client, snapshotName string) *types.Snapshot {
log.WithField("snapshotName", snapshotName).Info("get snapshot by rackspace.Name")
snapshots, err := client.API().Snapshots(nil)
assert.NoError(t, err)
if err != nil {
t.FailNow()
}
assert.Contains(t, snapshots, rackspace.Name)
for _, vol := range snapshots[rackspace.Name] {
if vol.Name == snapshotName {
return vol
}
}
t.FailNow()
t.Error("failed snapshotByName")
return nil
}
func volumeByName(
t *testing.T, client types.Client, volumeName string) *types.Volume {
log.WithField("volumeName", volumeName).Info("get volume byrackspace.Name")
vols, err := client.API().Volumes(nil, 0)
assert.NoError(t, err)
if err != nil {
t.FailNow()
}
assert.Contains(t, vols, rackspace.Name)
for _, vol := range vols[rackspace.Name] {
if vol.Name == volumeName {
return vol
}
}
t.FailNow()
t.Error("failed volumeByName")
return nil
}
func snapshotCopy(
t *testing.T, client types.Client,
snapshotID, snapshotName, destinationID string) *types.Snapshot {
log.WithField("snapshotName", snapshotName).Info("copying snapshot")
snapshotCopyRequest := &types.SnapshotCopyRequest{
SnapshotName: snapshotName,
}
reply, err := client.API().SnapshotCopy(nil, rackspace.Name,
snapshotID, snapshotCopyRequest)
assert.NoError(t, err)
if err != nil {
t.FailNow()
t.Error("failed snapshotCopy")
}
apitests.LogAsJSON(reply, t)
assert.Equal(t, snapshotName, reply.Name)
return reply
}
// Test volume retrieval by volume ID using Volumes, which retrieves all
// volumes from the storage driver without filtering, and filters the volumes
// externally. Contrast with volumeInspect, which directly retrieves matching
// volumes from the storage driver.
func volumeByID(
t *testing.T, client types.Client, volumeID string) *types.Volume {
log.WithField("volumeID", volumeID).Info("get volume by ebs.Name using ID")
// Retrieve all volumes
vols, err := client.API().Volumes(nil, 0)
assert.NoError(t, err)
if err != nil {
t.FailNow()
}
// Filter volumes to those under the ec2 service,
// and find a volume matching inputted volume ID
assert.Contains(t, vols, ebs.Name)
for _, vol := range vols[ebs.Name] {
if vol.ID == volumeID {
return vol
}
}
// No matching volumes found
t.FailNow()
t.Error("failed volumeByID")
return nil
}
func volumeCreateFromSnapshot(
t *testing.T, client types.Client,
snapshotID, volumeName string) *types.Volume {
fields := map[string]interface{}{
"snapshotID": snapshotID,
"volumeName": volumeName,
}
log.WithFields(fields).Info("creating volume from snapshot")
size := int64(8)
opts := map[string]interface{}{
"priority": 2,
"owner": "*****@*****.**",
}
volumeCreateRequest := &types.VolumeCreateRequest{
Name: volumeName,
Size: &size,
Opts: opts,
}
reply, err := client.API().VolumeCreateFromSnapshot(nil,
rackspace.Name, snapshotID, volumeCreateRequest)
assert.NoError(t, err)
if err != nil {
t.FailNow()
t.Error("failed volumeCreateFromSnapshot")
}
apitests.LogAsJSON(reply, t)
assert.Equal(t, volumeName, reply.Name)
assert.Equal(t, size, reply.Size)
assert.Equal(t, opts["priority"], 2)
assert.Equal(t, opts["owner"], "*****@*****.**")
return reply
}