Returns a `list` of all the `Volume` known to the cluster.  Updates every time - no caching.
        :return: a `list` of all the `Volume` known to the cluster.
        :rtype: list
558782
def volumes(self):
        
        self.connection._check_login()
        response = self.connection._do_get("{}/{}".format(self.connection._api_url, "types/Volume/instances")).json()
        all_volumes = []
        for volume in response:
            all_volumes.append(
                SIO_Volume.from_dict(volume)
            )
        return all_volumes
1220078
def get_shm_volumes():
    
    volumes, volume_mounts = [], []
    shm_volume = client.V1Volume(
        name=constants.SHM_VOLUME,
        empty_dir=client.V1EmptyDirVolumeSource(medium='Memory')
    )
    volumes.append(shm_volume)
    shm_volume_mount = client.V1VolumeMount(name=shm_volume.name, mount_path='/dev/shm')
    volume_mounts.append(shm_volume_mount)
    return volumes, volume_mounts
1045725
def parse_volumes_output(out):
    
    if not out:
        return []
    line_iter = islice(out.splitlines(), 1, None)  # Skip header
    return list(map(_volume_info, line_iter))
1102078
def get_volumes(self):
        """"""

        volumes = []
        for disk in self.disks:
            volumes.extend(disk.get_volumes())
        return volumes
906421
def snapshots(self):
        
        self.connection._check_login()
        response = self.connection._do_get("{}/{}".format(self.connection._api_url, "types/Volume/instances")).json()
        all_volumes_snapshot = []
        for volume in response:
            if volume['volumeType'] == 'Snapshot':
                all_volumes_snapshot.append(
                    Volume.from_dict(volume)
            )
        return all_volumes_snapshot
26326
def storage_volume_templates(self):
        
        if not self.__storage_volume_templates:
            self.__storage_volume_templates = StorageVolumeTemplates(self.__connection)
        return self.__storage_volume_templates
37094
def folders(self):
        ''''''
        if self._folders is None :
            self.__init()
        if self._folders is not None and isinstance(self._folders, list):
            if len(self._folders) == 0:
                self._loadFolders()
        return self._folders
995544
def get_volumes(self):
        """"""

        if self.volumes:
            volumes = []
            for v in self.volumes:
                volumes.extend(v.get_volumes())
            volumes.append(self)
            return volumes
        else:
            return [self]
760462
def close_available(self):
        
        return {
            'volume_long': self.volume_long - self.volume_long_frozen,
            'volume_short': self.volume_short - self.volume_short_frozen
        }
532409
def storage_volume_attachments(self):
        
        if not self.__storage_volume_attachments:
            self.__storage_volume_attachments = StorageVolumeAttachments(self.__connection)
        return self.__storage_volume_attachments
327802
def get_volumes_for_instance(self, arg, device=None):
        
        instance = self.get(arg)
        filters = {'attachment.instance-id': instance.id}
        if device is not None:
            filters['attachment.device'] = device
        return self.get_all_volumes(filters=filters)
145354
def listVolumes(self):
        
        for (vol, paths) in self.paths.items():
            for path in paths:
                if path.startswith('/'):
                    continue
                if path == '.':
                    continue
                if self.userVolume is not None and os.path.basename(path) != self.userVolume:
                    continue
                yield vol
                break
879436
def get_shard_names(self):
        
        results = []
        for shard_num in range(0, self.num_shards()):
            shard_name = self.get_shard_name(shard_num)
            results.append(shard_name)

        return results
910814
def volume_present(name, provider=None, **kwargs):
    '''
    
    '''
    ret = _check_name(name)
    if not ret['result']:
        return ret

    volumes = __salt__['cloud.volume_list'](provider=provider)

    if name in volumes:
        ret['comment'] = 'Volume exists: {0}'.format(name)
        ret['result'] = True
        return ret
    elif __opts__['test']:
        ret['comment'] = 'Volume {0} will be created.'.format(name)
        ret['result'] = None
        return ret

    response = __salt__['cloud.volume_create'](
        names=name,
        provider=provider,
        **kwargs
    )
    if response:
        ret['result'] = True
        ret['comment'] = 'Volume {0} was created'.format(name)
        ret['changes'] = {'old': None, 'new': response}
    else:
        ret['result'] = False
        ret['comment'] = 'Volume {0} failed to create.'.format(name)
    return ret
676098
def flows(self):
        
        if self._flows is None:
            self._flows = FlowList(self)
        return self._flows
1210957
public java.util.List<VolumeConfiguration> getVolumeConfigurations() {
        if (volumeConfigurations == null) {
            volumeConfigurations = new com.amazonaws.internal.SdkInternalList<VolumeConfiguration>();
        }
        return volumeConfigurations;
    }
950060
public java.util.List<VolumeRecoveryPointInfo> getVolumeRecoveryPointInfos() {
        if (volumeRecoveryPointInfos == null) {
            volumeRecoveryPointInfos = new com.amazonaws.internal.SdkInternalList<VolumeRecoveryPointInfo>();
        }
        return volumeRecoveryPointInfos;
    }