// // VolumeRemove removes a volume. func (d *driver) VolumeRemove( ctx types.Context, volumeID string, opts types.Store) error { fields := eff(map[string]interface{}{ "volumeId": volumeID, }) if volumeID == "" { return goof.WithFields(fields, "volumeId is required") } attached, err := d.volumeAttached(ctx, volumeID) if err != nil { return goof.WithFieldsE(fields, "error retrieving attachment status", err) } if attached { _, err := d.VolumeDetach(ctx, volumeID, &types.VolumeDetachOpts{}) if err != nil { return goof.WithFieldsE(fields, "error detaching before volume removal", err) } } res := volumes.Delete(d.clientBlockStorage, volumeID) if res.Err != nil { return goof.WithFieldsE(fields, "error removing volume", res.Err) } return nil }
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 (command *commandDelete) Execute(resource *handler.Resource) { volumeID := resource.Params.(*paramsDelete).volumeID err := osVolumes.Delete(command.Ctx.ServiceClient, volumeID).ExtractErr() if err != nil { resource.Err = err return } resource.Result = fmt.Sprintf("Deleting volume [%s]\n", volumeID) }
func (driver *Driver) RemoveVolume(volumeID string) error { if volumeID == "" { return ErrMissingVolumeID } res := volumes.Delete(driver.ClientBlockStorage, volumeID) if res.Err != nil { return res.Err } log.Println("Deleted Volume: " + volumeID) return nil }
func (os *OpenStack) DeleteVolume(volumeName string) error { sClient, err := openstack.NewBlockStorageV1(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil || sClient == nil { glog.Errorf("Unable to initialize cinder client for region: %s", os.region) return err } err = volumes.Delete(sClient, volumeName).ExtractErr() if err != nil { glog.Errorf("Cannot delete volume %s: %v", volumeName, err) } return err }
func (d *driver) RemoveVolume(volumeID string) error { fields := eff(map[string]interface{}{ "volumeId": volumeID, }) if volumeID == "" { return errors.WithFields(fields, "volumeId is required") } res := volumes.Delete(d.clientBlockStorage, volumeID) if res.Err != nil { return errors.WithFieldsE(fields, "error removing volume", res.Err) } log.WithFields(fields).Debug("removed volume") return nil }
func TestAttachVolume(t *testing.T) { choices, err := ComputeChoicesFromEnv() if err != nil { t.Fatal(err) } computeClient, err := newClient() if err != nil { t.Fatalf("Unable to create a compute client: %v", err) } blockClient, err := newBlockClient(t) if err != nil { t.Fatalf("Unable to create a blockstorage client: %v", err) } server, err := createVAServer(t, computeClient, choices) if err != nil { t.Fatalf("Unable to create server: %v", err) } defer func() { servers.Delete(computeClient, server.ID) t.Logf("Server deleted.") }() if err = waitForStatus(computeClient, server, "ACTIVE"); err != nil { t.Fatalf("Unable to wait for server: %v", err) } volume, err := createVAVolume(t, blockClient) if err != nil { t.Fatalf("Unable to create volume: %v", err) } defer func() { err = volumes.Delete(blockClient, volume.ID).ExtractErr() th.AssertNoErr(t, err) t.Logf("Volume deleted.") }() createVolumeAttachment(t, computeClient, blockClient, server.ID, volume.ID) }
func (os *OpenStack) DeleteVolume(volumeName string) error { used, err := os.diskIsUsed(volumeName) if err != nil { return err } if used { msg := fmt.Sprintf("Cannot delete the volume %q, it's still attached to a node", volumeName) return volume.NewDeletedVolumeInUseError(msg) } sClient, err := openstack.NewBlockStorageV1(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil || sClient == nil { glog.Errorf("Unable to initialize cinder client for region: %s", os.region) return err } err = volumes.Delete(sClient, volumeName).ExtractErr() if err != nil { glog.Errorf("Cannot delete volume %s: %v", volumeName, err) } return 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 resourceBlockStorageVolumeV1Delete(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) blockStorageClient, err := config.blockStorageV1Client(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: VolumeV1StateRefreshFunc(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: VolumeV1StateRefreshFunc(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 }
// Delete will delete the existing Volume with the provided ID. func Delete(client *gophercloud.ServiceClient, id string) os.DeleteResult { return os.Delete(client, id) }