func createVolumeAttachment(t *testing.T, computeClient *gophercloud.ServiceClient, blockClient *gophercloud.ServiceClient, serverId string, volumeId string) {
va, err := volumeattach.Create(computeClient, serverId, &volumeattach.CreateOpts{
VolumeID: volumeId,
}).Extract()
th.AssertNoErr(t, err)
defer func() {
err = volumes.WaitForStatus(blockClient, volumeId, "in-use", 60)
th.AssertNoErr(t, err)
err = volumeattach.Delete(computeClient, serverId, va.ID).ExtractErr()
th.AssertNoErr(t, err)
err = volumes.WaitForStatus(blockClient, volumeId, "available", 60)
th.AssertNoErr(t, err)
}()
}
func TestSnapshots(t *testing.T) {
client, err := newClient(t)
th.AssertNoErr(t, err)
v, err := volumes.Create(client, &volumes.CreateOpts{
Name: "gophercloud-test-volume",
Size: 1,
}).Extract()
th.AssertNoErr(t, err)
err = volumes.WaitForStatus(client, v.ID, "available", 120)
th.AssertNoErr(t, err)
t.Logf("Created volume: %v\n", v)
ss, err := snapshots.Create(client, &snapshots.CreateOpts{
Name: "gophercloud-test-snapshot",
VolumeID: v.ID,
}).Extract()
th.AssertNoErr(t, err)
err = snapshots.WaitForStatus(client, ss.ID, "available", 120)
th.AssertNoErr(t, err)
t.Logf("Created snapshot: %+v\n", ss)
err = snapshots.Delete(client, ss.ID).ExtractErr()
th.AssertNoErr(t, err)
err = gophercloud.WaitFor(120, func() (bool, error) {
_, err := snapshots.Get(client, ss.ID).Extract()
if err != nil {
return true, nil
}
return false, nil
})
th.AssertNoErr(t, err)
t.Log("Deleted snapshot\n")
err = volumes.Delete(client, v.ID).ExtractErr()
th.AssertNoErr(t, err)
err = gophercloud.WaitFor(120, func() (bool, error) {
_, err := volumes.Get(client, v.ID).Extract()
if err != nil {
return true, nil
}
return false, nil
})
th.AssertNoErr(t, err)
t.Log("Deleted volume\n")
}
func createVAVolume(t *testing.T, blockClient *gophercloud.ServiceClient) (*volumes.Volume, error) {
volume, err := volumes.Create(blockClient, &volumes.CreateOpts{
Size: 1,
Name: "gophercloud-test-volume",
}).Extract()
th.AssertNoErr(t, err)
defer func() {
err = volumes.WaitForStatus(blockClient, volume.ID, "available", 60)
th.AssertNoErr(t, err)
}()
return volume, err
}
func TestVolumes(t *testing.T) {
client, err := newClient(t)
th.AssertNoErr(t, err)
cv, err := volumes.Create(client, &volumes.CreateOpts{
Size: 1,
Name: "gophercloud-test-volume",
}).Extract()
th.AssertNoErr(t, err)
defer func() {
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
err = volumes.Delete(client, cv.ID).ExtractErr()
th.AssertNoErr(t, err)
}()
_, err = volumes.Update(client, cv.ID, &volumes.UpdateOpts{
Name: "gophercloud-updated-volume",
}).Extract()
th.AssertNoErr(t, err)
v, err := volumes.Get(client, cv.ID).Extract()
th.AssertNoErr(t, err)
t.Logf("Got volume: %+v\n", v)
if v.Name != "gophercloud-updated-volume" {
t.Errorf("Unable to update volume: Expected name: gophercloud-updated-volume\nActual name: %s", v.Name)
}
err = volumes.List(client, &volumes.ListOpts{Name: "gophercloud-updated-volume"}).EachPage(func(page pagination.Page) (bool, error) {
vols, err := volumes.ExtractVolumes(page)
th.CheckEquals(t, 1, len(vols))
return true, err
})
th.AssertNoErr(t, err)
}
func (d *driver) CreateVolume(
runAsync bool,
volumeName string,
volumeID string,
snapshotID string,
volumeType string,
IOPS int64,
size int64,
availabilityZone string) (*core.Volume, error) {
fields := map[string]interface{}{
"provider": providerName,
"runAsync": runAsync,
"volumeName": volumeName,
"volumeId": volumeID,
"snapshotId": snapshotID,
"volumeType": volumeType,
"iops": IOPS,
"size": size,
"availabilityZone": availabilityZone,
}
if volumeID != "" && runAsync {
return nil, errors.ErrRunAsyncFromVolume
}
d.createVolumeEnsureAvailabilityZone(&availabilityZone)
var err error
if err = d.createVolumeHandleSnapshotID(
&size, snapshotID, fields); err != nil {
return nil, err
}
var volume []*core.Volume
if volume, err = d.createVolumeHandleVolumeID(
&availabilityZone, &snapshotID, &volumeID, &size, fields); err != nil {
return nil, err
}
createVolumeEnsureSize(&size)
options := &volumes.CreateOpts{
Name: volumeName,
Size: int(size),
SnapshotID: snapshotID,
VolumeType: volumeType,
Availability: availabilityZone,
}
resp, err := volumes.Create(d.clientBlockStorage, options).Extract()
if err != nil {
return nil,
errors.WithFields(fields, "error creating volume")
}
if !runAsync {
log.Debug("waiting for volume creation to complete")
err = volumes.WaitForStatus(d.clientBlockStorage, resp.ID, "available", 120)
if err != nil {
return nil,
errors.WithFields(fields,
"error waiting for volume creation to complete")
}
if volumeID != "" {
err := d.RemoveSnapshot(snapshotID)
if err != nil {
return nil,
errors.WithFields(fields,
"error removing snapshot")
}
}
}
fields["volumeId"] = resp.ID
fields["volumeName"] = ""
volume, err = d.GetVolume(resp.ID, "")
if err != nil {
return nil, errors.WithFields(fields,
"error removing snapshot")
}
log.WithFields(fields).Debug("created volume")
return volume[0], nil
}
func (driver *Driver) CreateVolume(
runAsync bool,
volumeName string,
volumeID string,
snapshotID string,
volumeType string,
IOPS int64,
size int64,
availabilityZone string) (*storage.Volume, error) {
fields := map[string]interface{}{
"provider": ProviderName,
"runAsync": runAsync,
"volumeName": volumeName,
"volumeId": volumeID,
"snapshotId": snapshotID,
"volumeType": volumeType,
"iops": IOPS,
"size": size,
"availabilityZone": availabilityZone,
}
if volumeID != "" && runAsync {
return nil, errors.WithFields(fields,
"cannot create volume from volume & run async")
}
if snapshotID != "" {
snapshot, err := driver.GetSnapshot("", snapshotID, "")
if err != nil {
return nil,
errors.WithFieldsE(fields, "error getting snapshot", err)
}
if len(snapshot) == 0 {
return nil,
errors.WithFields(fields, "snapshot array is empty")
}
volSize := snapshot[0].VolumeSize
sizeInt, err := strconv.Atoi(volSize)
if err != nil {
f := errors.Fields{
"volumeSize": volSize,
}
for k, v := range fields {
f[k] = v
}
return nil,
errors.WithFieldsE(f, "error casting volume size", err)
}
size = int64(sizeInt)
}
var volume []*storage.Volume
var err error
if volumeID != "" {
volume, err = driver.GetVolume(volumeID, "")
if err != nil {
return nil, errors.WithFields(fields, "error getting volume")
}
if len(volume) == 0 {
return nil,
errors.WithFields(fields, "volume array is empty")
}
volSize := volume[0].Size
sizeInt, err := strconv.Atoi(volSize)
if err != nil {
f := errors.Fields{
"volumeSize": volSize,
}
for k, v := range fields {
f[k] = v
}
return nil,
errors.WithFieldsE(f, "error casting volume size", err)
}
size = int64(sizeInt)
volumeID := volume[0].VolumeID
snapshot, err := driver.CreateSnapshot(
false, fmt.Sprintf("temp-%s", volumeID), volumeID, "")
if err != nil {
return nil,
errors.WithFields(fields, "error creating snapshot")
}
snapshotID = snapshot[0].SnapshotID
if availabilityZone == "" {
availabilityZone = volume[0].AvailabilityZone
}
}
if size != 0 && size < minSize {
size = minSize
}
options := &volumes.CreateOpts{
Name: volumeName,
Size: int(size),
SnapshotID: snapshotID,
VolumeType: volumeType,
Availability: availabilityZone,
}
resp, err := volumes.Create(driver.ClientBlockStorage, options).Extract()
if err != nil {
return nil,
errors.WithFields(fields, "error creating volume")
}
if !runAsync {
log.Debug("waiting for volume creation to complete")
err = volumes.WaitForStatus(driver.ClientBlockStorage, resp.ID, "available", 120)
if err != nil {
return nil,
errors.WithFields(fields,
"error waiting for volume creation to complete")
}
if volumeID != "" {
err := driver.RemoveSnapshot(snapshotID)
if err != nil {
return nil,
errors.WithFields(fields,
"error removing snapshot")
}
}
}
fields["volumeId"] = resp.ID
fields["volumeName"] = ""
volume, err = driver.GetVolume(resp.ID, "")
if err != nil {
return nil, errors.WithFields(fields,
"error removing snapshot")
}
log.WithFields(fields).Debug("created volume")
return volume[0], nil
}
func (driver *Driver) CreateVolume(runAsync bool, volumeName string, volumeID string, snapshotID string, volumeType string, IOPS int64, size int64, availabilityZone string) (*storagedriver.Volume, error) {
if volumeID != "" && runAsync {
return nil, errors.New("Cannot create volume from volume and run asynchronously")
}
if snapshotID != "" {
snapshot, err := driver.GetSnapshot("", snapshotID, "")
if err != nil {
return nil, err
}
sizeInt, err := strconv.Atoi(snapshot[0].VolumeSize)
if err != nil {
return nil, err
}
size = int64(sizeInt)
}
var volume []*storagedriver.Volume
var err error
if volumeID != "" {
volume, err = driver.GetVolume(volumeID, "")
if err != nil {
return nil, err
}
sizeInt, err := strconv.Atoi(volume[0].Size)
if err != nil {
return nil, err
}
size = int64(sizeInt)
volumeID := volume[0].VolumeID
snapshot, err := driver.CreateSnapshot(false, fmt.Sprintf("temp-%s", volumeID), volumeID, "")
if err != nil {
return nil, err
}
snapshotID = snapshot[0].SnapshotID
if availabilityZone == "" {
availabilityZone = volume[0].AvailabilityZone
}
}
if size != 0 && size < minSize {
size = minSize
}
options := &volumes.CreateOpts{
Name: volumeName,
Size: int(size),
SnapshotID: snapshotID,
VolumeType: volumeType,
Availability: availabilityZone,
}
resp, err := volumes.Create(driver.ClientBlockStorage, options).Extract()
if err != nil {
return nil, err
}
if !runAsync {
log.Println("Waiting for volume creation to complete")
err = volumes.WaitForStatus(driver.ClientBlockStorage, resp.ID, "available", 120)
if err != nil {
return nil, err
}
if volumeID != "" {
err := driver.RemoveSnapshot(snapshotID)
if err != nil {
return nil, err
}
}
}
volume, err = driver.GetVolume(resp.ID, "")
if err != nil {
return nil, err
}
// log.Println(fmt.Sprintf("Created volume: %+v", volume[0]))
return volume[0], nil
}
func (d *driver) createVolume(
ctx types.Context,
volumeName string,
volumeSourceID string,
snapshotID string,
opts *types.VolumeCreateOpts) (*types.Volume, error) {
var (
volumeType string
IOPS int64
size int64
availabilityZone string
)
if opts.Type != nil {
volumeType = *(opts.Type)
}
if opts.IOPS != nil {
IOPS = *(opts.IOPS)
}
if opts.Size != nil {
size = *(opts.Size)
}
if opts.AvailabilityZone != nil {
availabilityZone = *(opts.AvailabilityZone)
}
//check some fields...
createVolumeEnsureSize(&size)
vsize := int(size)
fields := map[string]interface{}{
"availabilityZone": availabilityZone,
"iops": IOPS,
"provider": d.Name(),
"size": size,
"snapshotId": snapshotID,
"volumeName": volumeName,
"volumeSourceID": volumeSourceID,
"volumeType": volumeType,
}
options := &volumes.CreateOpts{
Name: volumeName,
Size: vsize,
SnapshotID: snapshotID,
VolumeType: volumeType,
//AvailabilityZone: availabilityZone, //Not in old Rackspace
//SourceReplica: volumeSourceID,
}
resp, err := volumes.Create(d.clientBlockStorage, options).Extract()
if err != nil {
return nil,
goof.WithFields(fields, "error creating volume")
}
fields["volumeId"] = resp.ID
//for openstack must test before rackspace integration
err = volumes.WaitForStatus(d.clientBlockStorage, resp.ID, "available", 120)
if err != nil {
return nil,
goof.WithFieldsE(fields,
"error waiting for volume creation to complete", err)
}
log.WithFields(fields).Debug("created volume")
return translateVolume(resp, types.VolAttReqTrue), nil
}