func (driver *Driver) getBlockDevices() ([]*goscaleio.SdcMappedVolume, error) {
volumeMaps, err := goscaleio.GetLocalVolumeMap()
if err != nil {
return []*goscaleio.SdcMappedVolume{}, ErrLocalVolumeMaps
}
return volumeMaps, nil
}
func (d *driver) getBlockDevices() ([]*goscaleio.SdcMappedVolume, error) {
volumeMaps, err := goscaleio.GetLocalVolumeMap()
if err != nil {
return []*goscaleio.SdcMappedVolume{},
goof.WithFieldsE(ef(), "error getting local volume map", err)
}
return volumeMaps, nil
}
func waitMount(volumeID string) (*goscaleio.SdcMappedVolume, error) {
timeout := make(chan bool, 1)
go func() {
time.Sleep(10 * time.Second)
timeout <- true
}()
successCh := make(chan *goscaleio.SdcMappedVolume, 1)
errorCh := make(chan error, 1)
go func(volumeID string) {
log.WithField("provider", providerName).Debug("waiting for volume mount")
for {
sdcMappedVolumes, err := goscaleio.GetLocalVolumeMap()
if err != nil {
errorCh <- goof.WithFieldE(
"provider", providerName,
"problem getting local volume mappings", err)
return
}
sdcMappedVolume := &goscaleio.SdcMappedVolume{}
var foundVolume bool
for _, sdcMappedVolume = range sdcMappedVolumes {
if sdcMappedVolume.VolumeID ==
volumeID && sdcMappedVolume.SdcDevice != "" {
foundVolume = true
break
}
}
if foundVolume {
successCh <- sdcMappedVolume
return
}
time.Sleep(100 * time.Millisecond)
}
}(volumeID)
select {
case sdcMappedVolume := <-successCh:
log.WithFields(log.Fields{
"provider": providerName,
"volumeId": sdcMappedVolume.VolumeID,
"volume": sdcMappedVolume.SdcDevice,
}).Debug("got sdcMappedVolume")
return sdcMappedVolume, nil
case err := <-errorCh:
return &goscaleio.SdcMappedVolume{}, err
case <-timeout:
return &goscaleio.SdcMappedVolume{}, goof.WithFields(
ef(), "timed out waiting for mount")
}
}
func (d *driver) GetVolume(
volumeID, volumeName string) ([]*core.Volume, error) {
sdcMappedVolumes, err := goscaleio.GetLocalVolumeMap()
if err != nil {
return []*core.Volume{}, err
}
sdcDeviceMap := make(map[string]*goscaleio.SdcMappedVolume)
for _, sdcMappedVolume := range sdcMappedVolumes {
sdcDeviceMap[sdcMappedVolume.VolumeID] = sdcMappedVolume
}
volumes, err := d.getVolume(volumeID, volumeName)
if err != nil {
return []*core.Volume{}, err
}
var volumesSD []*core.Volume
for _, volume := range volumes {
var attachmentsSD []*core.VolumeAttachment
for _, attachment := range volume.MappedSdcInfo {
var deviceName string
if attachment.SdcID == d.sdc.Sdc.ID {
if _, exists := sdcDeviceMap[volume.ID]; exists {
deviceName = sdcDeviceMap[volume.ID].SdcDevice
}
}
attachmentSD := &core.VolumeAttachment{
VolumeID: volume.ID,
InstanceID: attachment.SdcID,
DeviceName: deviceName,
Status: "",
}
attachmentsSD = append(attachmentsSD, attachmentSD)
}
var IOPS int64
if len(volume.MappedSdcInfo) > 0 {
IOPS = int64(volume.MappedSdcInfo[0].LimitIops)
}
volumeSD := &core.Volume{
Name: volume.Name,
VolumeID: volume.ID,
AvailabilityZone: d.protectionDomain.ProtectionDomain.ID,
Status: "",
VolumeType: volume.StoragePoolID,
IOPS: IOPS,
Size: strconv.Itoa(volume.SizeInKb / 1024 / 1024),
Attachments: attachmentsSD,
}
volumesSD = append(volumesSD, volumeSD)
}
return volumesSD, nil
}
func waitMount(volumeID string) (*goscaleio.SdcMappedVolume, error) {
timeout := make(chan bool, 1)
go func() {
time.Sleep(10 * time.Second)
timeout <- true
}()
successCh := make(chan *goscaleio.SdcMappedVolume, 1)
errorCh := make(chan error, 1)
go func(volumeID string) {
log.Println("ScaleIO: waiting for volume mount")
for {
sdcMappedVolumes, err := goscaleio.GetLocalVolumeMap()
if err != nil {
errorCh <- fmt.Errorf("ScaleIO: problem getting local volume mappings: %s", err)
return
}
sdcMappedVolume := &goscaleio.SdcMappedVolume{}
var foundVolume bool
for _, sdcMappedVolume = range sdcMappedVolumes {
if sdcMappedVolume.VolumeID == volumeID && sdcMappedVolume.SdcDevice != "" {
foundVolume = true
break
}
}
if foundVolume {
successCh <- sdcMappedVolume
return
}
time.Sleep(100 * time.Millisecond)
}
}(volumeID)
select {
case sdcMappedVolume := <-successCh:
log.Println(fmt.Sprintf("ScaleIO: got sdcMappedVolume %s at %s", sdcMappedVolume.VolumeID, sdcMappedVolume.SdcDevice))
return sdcMappedVolume, nil
case err := <-errorCh:
return &goscaleio.SdcMappedVolume{}, err
case <-timeout:
return &goscaleio.SdcMappedVolume{}, fmt.Errorf("ScaleIO: timed out waiting for mount")
}
}