func (driver *Driver) DetachVolume(runAsync bool, volumeID string, blank string) error {
if volumeID == "" {
return ErrMissingVolumeID
}
volumes, err := driver.getVolume(volumeID, "")
if err != nil {
return err
}
if len(volumes) == 0 {
return ErrNoVolumesReturned
}
targetVolume := goscaleio.NewVolume(driver.Client)
targetVolume.Volume = volumes[0]
unmapVolumeSdcParam := &types.UnmapVolumeSdcParam{
SdcID: driver.Sdc.Sdc.ID,
IgnoreScsiInitiators: "true",
AllSdcs: "",
}
// need to detect if unmounted first
err = targetVolume.UnmapVolumeSdc(unmapVolumeSdcParam)
if err != nil {
return err
}
log.Println("Detached volume", volumeID)
return nil
}
func (d *driver) RemoveVolume(volumeID string) error {
fields := eff(map[string]interface{}{
"volumeId": volumeID,
})
if volumeID == "" {
return goof.WithFields(fields, "volumeId is required")
}
var err error
var volumes []*types.Volume
if volumes, err = d.getVolume(volumeID, "", false); err != nil {
return goof.WithFieldsE(fields, "error getting volume", err)
}
targetVolume := goscaleio.NewVolume(d.client)
targetVolume.Volume = volumes[0]
if err = targetVolume.RemoveVolume("ONLY_ME"); err != nil {
return goof.WithFieldsE(fields, "error removing volume", err)
}
log.WithFields(fields).Debug("removed volume")
return nil
}
func (driver *Driver) RemoveVolume(volumeID string) error {
fields := eff(map[string]interface{}{
"volumeId": volumeID,
})
if volumeID == "" {
return errors.WithFields(fields, "volumeId is required")
}
volumes, err := driver.getVolume(volumeID, "")
if err != nil {
return errors.WithFieldsE(fields, "error getting volume", err)
}
targetVolume := goscaleio.NewVolume(driver.Client)
targetVolume.Volume = volumes[0]
err = targetVolume.RemoveVolume("ONLY_ME")
if err != nil {
return errors.WithFieldsE(fields, "error removing volume", err)
}
log.WithFields(fields).Debug("removed volume")
return nil
}
func (d *driver) AttachVolume(
runAsync bool,
volumeID, instanceID string) ([]*core.VolumeAttachment, error) {
fields := eff(map[string]interface{}{
"runAsync": runAsync,
"volumeId": volumeID,
"instanceId": instanceID,
})
if volumeID == "" {
return nil, errors.WithFields(fields, "volumeId is required")
}
mapVolumeSdcParam := &types.MapVolumeSdcParam{
SdcID: d.sdc.Sdc.ID,
AllowMultipleMappings: "false",
AllSdcs: "",
}
volumes, err := d.getVolume(volumeID, "")
if err != nil {
return nil, errors.WithFieldsE(fields, "error getting volume", err)
}
if len(volumes) == 0 {
return nil, errors.WithFields(fields, "no volumes returned")
}
targetVolume := goscaleio.NewVolume(d.client)
targetVolume.Volume = volumes[0]
err = targetVolume.MapVolumeSdc(mapVolumeSdcParam)
if err != nil {
return nil, errors.WithFieldsE(fields, "error mapping volume sdc", err)
}
_, err = waitMount(volumes[0].ID)
if err != nil {
fields["volumeId"] = volumes[0].ID
return nil, errors.WithFieldsE(
fields, "error waiting on volume to mount", err)
}
volumeAttachment, err := d.GetVolumeAttach(volumeID, instanceID)
if err != nil {
return nil, errors.WithFieldsE(
fields, "error getting volume attachments", err)
}
log.WithFields(log.Fields{
"provider": providerName,
"volumeId": volumeID,
"instanceId": instanceID,
}).Debug("attached volume to instance")
return volumeAttachment, nil
}
func (d *driver) DetachVolume(
runAsync bool, volumeID string, blank string, force bool) error {
fields := eff(map[string]interface{}{
"runAsync": runAsync,
"volumeId": volumeID,
"blank": blank,
})
if volumeID == "" {
return goof.WithFields(fields, "volumeId is required")
}
volumes, err := d.getVolume(volumeID, "", false)
if err != nil {
return goof.WithFieldsE(fields, "error getting volume", err)
}
if len(volumes) == 0 {
return goof.WithFields(fields, "no volumes returned")
}
targetVolume := goscaleio.NewVolume(d.client)
targetVolume.Volume = volumes[0]
unmapVolumeSdcParam := &types.UnmapVolumeSdcParam{
SdcID: "",
IgnoreScsiInitiators: "true",
AllSdcs: "",
}
if force {
unmapVolumeSdcParam.AllSdcs = "true"
} else {
unmapVolumeSdcParam.SdcID = d.sdc.Sdc.ID
}
_ = targetVolume.UnmapVolumeSdc(unmapVolumeSdcParam)
log.WithFields(log.Fields{
"provider": providerName,
"volumeId": volumeID}).Debug("detached volume")
return nil
}
func (driver *Driver) AttachVolume(runAsync bool, volumeID, instanceID string) ([]*storagedriver.VolumeAttachment, error) {
if volumeID == "" {
return nil, ErrMissingVolumeID
}
mapVolumeSdcParam := &types.MapVolumeSdcParam{
SdcID: driver.Sdc.Sdc.ID,
AllowMultipleMappings: "false",
AllSdcs: "",
}
volumes, err := driver.getVolume(volumeID, "")
if err != nil {
return nil, err
}
if len(volumes) == 0 {
return nil, ErrNoVolumesReturned
}
targetVolume := goscaleio.NewVolume(driver.Client)
targetVolume.Volume = volumes[0]
err = targetVolume.MapVolumeSdc(mapVolumeSdcParam)
if err != nil {
return nil, err
}
_, err = waitMount(volumes[0].ID)
if err != nil {
return nil, err
}
volumeAttachment, err := driver.GetVolumeAttach(volumeID, instanceID)
if err != nil {
return nil, err
}
// log.Println(fmt.Sprintf("Attached volume %s to instance %s", volumeID, instanceID))
return volumeAttachment, nil
}
func (driver *Driver) DetachVolume(runAsync bool, volumeID string, blank string) error {
fields := eff(map[string]interface{}{
"runAsync": runAsync,
"volumeId": volumeID,
"blank": blank,
})
if volumeID == "" {
return errors.WithFields(fields, "volumeId is required")
}
volumes, err := driver.getVolume(volumeID, "")
if err != nil {
return errors.WithFieldsE(fields, "error getting volume", err)
}
if len(volumes) == 0 {
return errors.WithFields(fields, "no volumes returned")
}
targetVolume := goscaleio.NewVolume(driver.Client)
targetVolume.Volume = volumes[0]
unmapVolumeSdcParam := &types.UnmapVolumeSdcParam{
SdcID: driver.Sdc.Sdc.ID,
IgnoreScsiInitiators: "true",
AllSdcs: "",
}
// need to detect if unmounted first
err = targetVolume.UnmapVolumeSdc(unmapVolumeSdcParam)
if err != nil {
return errors.WithFieldsE(fields, "error unmapping volume sdc", err)
}
log.WithFields(log.Fields{
"provider": ProviderName,
"volumeId": volumeID}).Debug("detached volume")
return nil
}
func (driver *Driver) RemoveVolume(volumeID string) error {
if volumeID == "" {
return ErrMissingVolumeID
}
volumes, err := driver.getVolume(volumeID, "")
if err != nil {
return err
}
targetVolume := goscaleio.NewVolume(driver.Client)
targetVolume.Volume = volumes[0]
err = targetVolume.RemoveVolume("ONLY_ME")
if err != nil {
return err
}
log.Println("Deleted Volume: " + volumeID)
return nil
}