func TestVolumeActions(t *testing.T) {
client, err := newClient(t)
th.AssertNoErr(t, err)
cv, err := volumes.Create(client, &volumes.CreateOpts{
Size: 1,
Name: "blockv2-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.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
_, err = volumeactions.Attach(client, cv.ID, &volumeactions.AttachOpts{
MountPoint: "/mnt",
Mode: "rw",
InstanceUUID: "50902f4f-a974-46a0-85e9-7efc5e22dfdd",
}).Extract()
th.AssertNoErr(t, err)
err = volumes.WaitForStatus(client, cv.ID, "in-use", 60)
th.AssertNoErr(t, err)
_, err = volumeactions.Detach(client, cv.ID).Extract()
th.AssertNoErr(t, err)
}
func TestVolumeAttach(t *testing.T) {
client, err := newClient(t)
th.AssertNoErr(t, err)
t.Logf("Creating volume")
cv, err := volumes.Create(client, &volumes.CreateOpts{
Size: 1,
Name: "blockv2-volume",
}).Extract()
th.AssertNoErr(t, err)
defer func() {
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
t.Logf("Deleting volume")
err = volumes.Delete(client, cv.ID).ExtractErr()
th.AssertNoErr(t, err)
}()
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
instanceID := os.Getenv("OS_INSTANCE_ID")
if instanceID == "" {
t.Fatal("Environment variable OS_INSTANCE_ID is required")
}
t.Logf("Attaching volume")
err = volumeactions.Attach(client, cv.ID, &volumeactions.AttachOpts{
MountPoint: "/mnt",
Mode: "rw",
InstanceUUID: instanceID,
}).ExtractErr()
th.AssertNoErr(t, err)
err = volumes.WaitForStatus(client, cv.ID, "in-use", 60)
th.AssertNoErr(t, err)
t.Logf("Detaching volume")
err = volumeactions.Detach(client, cv.ID).ExtractErr()
th.AssertNoErr(t, err)
}
func TestVolumeConns(t *testing.T) {
client, err := newClient(t)
th.AssertNoErr(t, err)
t.Logf("Creating volume")
cv, err := volumes.Create(client, &volumes.CreateOpts{
Size: 1,
Name: "blockv2-volume",
}).Extract()
th.AssertNoErr(t, err)
defer func() {
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
t.Logf("Deleting volume")
err = volumes.Delete(client, cv.ID).ExtractErr()
th.AssertNoErr(t, err)
}()
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
connOpts := &volumeactions.ConnectorOpts{
IP: "127.0.0.1",
Host: "stack",
Initiator: "iqn.1994-05.com.redhat:17cf566367d2",
Multipath: false,
Platform: "x86_64",
OSType: "linux2",
}
t.Logf("Initializing connection")
_, err = volumeactions.InitializeConnection(client, cv.ID, connOpts).Extract()
th.AssertNoErr(t, err)
t.Logf("Terminating connection")
err = volumeactions.TerminateConnection(client, cv.ID, connOpts).ExtractErr()
th.AssertNoErr(t, err)
}
func (d CinderDriver) Remove(r volume.Request) volume.Response {
log.Info("Remove/Delete Volume: ", r.Name)
vol, err := d.getByName(r.Name)
log.Debugf("Remove/Delete Volume ID: %s", vol.ID)
if err != nil {
log.Errorf("Failed to retrieve volume named: ", r.Name, "during Remove operation", err)
return volume.Response{Err: err.Error()}
}
errRes := volumes.Delete(d.Client, vol.ID)
log.Debugf("Response from Delete: %+v\n", errRes)
if errRes.Err != nil {
log.Errorf("Failed to Delete volume: %s\nEncountered error: %s", vol, errRes)
log.Debugf("Error message: %s", errRes.ExtractErr())
return volume.Response{Err: fmt.Sprintf("%s", errRes.ExtractErr())}
}
path := filepath.Join(d.Conf.MountPoint, r.Name)
if err := os.Remove(path); err != nil {
log.Error("Failed to remove Mount directory: %v", err)
return volume.Response{Err: err.Error()}
}
return volume.Response{}
}
func TestVolumeReserve(t *testing.T) {
client, err := newClient(t)
th.AssertNoErr(t, err)
t.Logf("Creating volume")
cv, err := volumes.Create(client, &volumes.CreateOpts{
Size: 1,
Name: "blockv2-volume",
}).Extract()
th.AssertNoErr(t, err)
defer func() {
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
t.Logf("Deleting volume")
err = volumes.Delete(client, cv.ID).ExtractErr()
th.AssertNoErr(t, err)
}()
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
t.Logf("Reserving volume")
err = volumeactions.Reserve(client, cv.ID).ExtractErr()
th.AssertNoErr(t, err)
err = volumes.WaitForStatus(client, cv.ID, "attaching", 60)
th.AssertNoErr(t, err)
t.Logf("Unreserving volume")
err = volumeactions.Unreserve(client, cv.ID).ExtractErr()
th.AssertNoErr(t, err)
err = volumes.WaitForStatus(client, cv.ID, "available", 60)
th.AssertNoErr(t, err)
}
func TestVolumes(t *testing.T) {
client, err := newClient(t)
th.AssertNoErr(t, err)
cv, err := volumes.Create(client, &volumes.CreateOpts{
Size: 1,
Name: "blockv2-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: "blockv2-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 != "blockv2-updated-volume" {
t.Errorf("Unable to update volume: Expected name: blockv2-updated-volume\nActual name: %s", v.Name)
}
err = volumes.List(client, &volumes.ListOpts{Name: "blockv2-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 resourceBlockStorageVolumeV2Delete(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
blockStorageClient, err := config.blockStorageV2Client(d.Get("region").(string))
if err != nil {
return fmt.Errorf("Error creating OpenStack block storage client: %s", err)
}
v, err := volumes.Get(blockStorageClient, d.Id()).Extract()
if err != nil {
return CheckDeleted(d, err, "volume")
}
// make sure this volume is detached from all instances before deleting
if len(v.Attachments) > 0 {
log.Printf("[DEBUG] detaching volumes")
if computeClient, err := config.computeV2Client(d.Get("region").(string)); err != nil {
return err
} else {
for _, volumeAttachment := range v.Attachments {
log.Printf("[DEBUG] Attachment: %v", volumeAttachment)
if err := volumeattach.Delete(computeClient, volumeAttachment["server_id"].(string), volumeAttachment["id"].(string)).ExtractErr(); err != nil {
return err
}
}
stateConf := &resource.StateChangeConf{
Pending: []string{"in-use", "attaching", "detaching"},
Target: []string{"available"},
Refresh: VolumeV2StateRefreshFunc(blockStorageClient, d.Id()),
Timeout: 10 * time.Minute,
Delay: 10 * time.Second,
MinTimeout: 3 * time.Second,
}
_, err = stateConf.WaitForState()
if err != nil {
return fmt.Errorf(
"Error waiting for volume (%s) to become available: %s",
d.Id(), err)
}
}
}
// It's possible that this volume was used as a boot device and is currently
// in a "deleting" state from when the instance was terminated.
// If this is true, just move on. It'll eventually delete.
if v.Status != "deleting" {
if err := volumes.Delete(blockStorageClient, d.Id()).ExtractErr(); err != nil {
return CheckDeleted(d, err, "volume")
}
}
// Wait for the volume to delete before moving on.
log.Printf("[DEBUG] Waiting for volume (%s) to delete", d.Id())
stateConf := &resource.StateChangeConf{
Pending: []string{"deleting", "downloading", "available"},
Target: []string{"deleted"},
Refresh: VolumeV2StateRefreshFunc(blockStorageClient, d.Id()),
Timeout: 10 * time.Minute,
Delay: 10 * time.Second,
MinTimeout: 3 * time.Second,
}
_, err = stateConf.WaitForState()
if err != nil {
return fmt.Errorf(
"Error waiting for volume (%s) to delete: %s",
d.Id(), err)
}
d.SetId("")
return nil
}
