Returns details about the specified volume.

        :param volume_id: ID of volume.
        :param kwargs:
        :return: Returns details about the specified volume.
422808
def get_file_volume_details(self, volume_id, **kwargs):
        

        if 'mask' not in kwargs:
            items = [
                'id',
                'username',
                'password',
                'capacityGb',
                'bytesUsed',
                'snapshotCapacityGb',
                'parentVolume.snapshotSizeBytes',
                'storageType.keyName',
                'serviceResource.datacenter[name]',
                'serviceResourceBackendIpAddress',
                'fileNetworkMountAddress',
                'storageTierLevel',
                'provisionedIops',
                'lunId',
                'originalVolumeName',
                'originalSnapshotName',
                'originalVolumeSize',
                'activeTransactionCount',
                'activeTransactions.transactionStatus[friendlyName]',
                'replicationPartnerCount',
                'replicationStatus',
                'replicationPartners[id,username,'
                'serviceResourceBackendIpAddress,'
                'serviceResource[datacenter[name]],'
                'replicationSchedule[type[keyname]]]',
            ]
            kwargs['mask'] = ','.join(items)
        return self.client.call('Network_Storage', 'getObject',
                                id=volume_id, **kwargs)
715252
def get_container_details(self, container_id_or_name: str) -> dict:
        
        container = self._client.containers.get(container_id_or_name)
        return container.attrs
62522
def volume_list(search_opts=None, profile=None, **kwargs):
    '''
    

    '''
    conn = _auth(profile, **kwargs)
    return conn.volume_list(search_opts=search_opts)
1339446
def get_by_index(self, index):
        """"""

        try:
            return self[index]
        except KeyError:
            for v in self.get_volumes():
                if v.index == str(index):
                    return v
        raise KeyError(index)
740506
def delete(self, volume_id, force=False):
        
        return self.http_delete('/volumes/%s/export'
                                % volume_id, params={'force': force})
1249984
async def SetVolumeInfo(self, volumes):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='StorageProvisioner',
                   request='SetVolumeInfo',
                   version=4,
                   params=_params)
        _params['volumes'] = volumes
        reply = await self.rpc(msg)
        return reply
1128793
def func(self, volume):
        
        return self._func(np.array(volume), self.eos_params)
745612
def get_volume_by_name(self, name):
        
        for vol in self.conn.volumes:
            if vol.name == name:
                return vol
        raise KeyError("Volume with NAME " + name + " not found")
43559
def os_volumes(self):
        
        if not self.__os_volumes:
            self.__os_volumes = OsVolumes(self.__connection)
        return self.__os_volumes
258130
def delete_volume(name)
      volume = get_volume(name)
      if !volume || !volume['id'] then
        puts "\nError: Volume '#{name}' does not exist"
        exit 1
      end

      params = {
          'command' => 'deleteVolume',
          'id' => volume['id']
      }

      json = send_request(params)
      json['success']
    end
941953
def volume_attach(provider, names, **kwargs):
    '''
    

    '''
    client = _get_client()
    info = client.extra_action(provider=provider, names=names, action='volume_attach', **kwargs)
    return info
420233
def get_volume_options(volumes):
        
        if not isinstance(volumes, list):
            volumes = [volumes]
        volumes = [Volume.create_from_tuple(v) for v in volumes]
        result = []
        for v in volumes:
            result += ["-v", str(v)]
        return result
1327978
def get_volume(name)
      params = {
          'command' => 'listVolumes',
          'name' => name
      }
      json = send_request(params)
      volumes = json['volume']

      if !volumes || volumes.empty? then
        return nil
      end
      volume = volumes.select { |item| name == item['name'] }
      volume.first
    end
1242339
private function getFolderByVolumeId(int $volumeId): VolumeFolder
    {
        return $this->mockFolder ? $this->mockFolder : VolumeFolder::findOne(['volumeId' => $volumeId]);
    }
1187885
def get_volume_list(self) -> list:
        
        # Initialising empty list
        volumes = []

        # Raise an exception if we are not a manager
        if not self._manager:
            raise RuntimeError('Only the Swarm manager node can retrieve'
                               ' all the services.')

        volume_list = self._client.volumes.list()
        for v_list in volume_list:
            volumes.append(v_list.name)
        return volumes
154985
def _volume_command(ramp, volume):
    
    if volume is not None:
        ramp.set_volume(float(volume))
    else:
        print ramp.volume
484948
def create(self, volume_id, backup_id=None, timestamp=None):
        
        backup_id = backup_id or str(uuid.uuid4())
        timestamp = timestamp or int(time())
        return self.http_put('/volumes/%s/backups/%s' % (volume_id, backup_id),
                             params={'timestamp': timestamp})