Struct AsyncHttpRangeReader 

pub struct AsyncHttpRangeReader { /* private fields */ }

An AsyncRangeReader enables reading from a file over HTTP using range requests.

See the crate level documentation for more information.

The general entrypoint is AsyncHttpRangeReader::new. Depending on the CheckSupportMethod, this will either call AsyncHttpRangeReader::initial_tail_request or AsyncHttpRangeReader::initial_head_request to send the initial request and then AsyncHttpRangeReader::from_tail_response or AsyncHttpRangeReader::from_head_response to initialize the async reader. If you want to apply a caching layer, you can send the initial head (or tail) request yourself with your cache headers (e.g. through the http-cache-semantics crate):

async fn get_reader_cached(
    url: Url,
) -> Result<Option<AsyncHttpRangeReader>, AsyncHttpRangeReaderError> {
    let etag = "63c550e8-5ae";
    let client = reqwest::Client::new();
    let response = client
        .head(url.clone())
        .header(reqwest::header::IF_NONE_MATCH, etag)
        .send()
        .await?;
    if response.status() == reqwest::StatusCode::NOT_MODIFIED {
        Ok(None)
    } else {
        let reader = AsyncHttpRangeReader::from_head_response(client, response, url, HeaderMap::default()).await?;
        Ok(Some(reader))
    }
}

Implementations

impl AsyncHttpRangeReader

pub async fn new( client: impl Into<ClientWithMiddleware>, url: Url, check_method: CheckSupportMethod, extra_headers: HeaderMap, ) -> Result<(Self, HeaderMap), AsyncHttpRangeReaderError>

Construct a new AsyncHttpRangeReader.

pub async fn initial_tail_request( client: impl Into<ClientWithMiddleware>, url: Url, initial_chunk_size: u64, extra_headers: HeaderMap, ) -> Result<Response, AsyncHttpRangeReaderError>

Send an initial range request to determine if the remote accepts range requests. This will return a number of bytes from the end of the stream. Use the initial_chunk_size parameter to define how many bytes should be requested from the end.

pub async fn from_tail_response( client: impl Into<ClientWithMiddleware>, tail_request_response: Response, url: Url, extra_headers: HeaderMap, ) -> Result<Self, AsyncHttpRangeReaderError>

Initialize the reader from AsyncHttpRangeReader::initial_tail_request (or a user provided response that also has a range of bytes from the end as body)

pub async fn initial_head_request( client: impl Into<ClientWithMiddleware>, url: Url, extra_headers: HeaderMap, ) -> Result<Response, AsyncHttpRangeReaderError>

Send an initial range request to determine if the remote accepts range requests and get the content length

pub async fn from_head_response( client: impl Into<ClientWithMiddleware>, head_response: Response, url: Url, extra_headers: HeaderMap, ) -> Result<Self, AsyncHttpRangeReaderError>

Initialize the reader from AsyncHttpRangeReader::initial_head_request (or a user provided response the)

pub async fn requested_ranges(&self) -> Vec<Range<u64>>

Returns the ranges that this instance actually performed HTTP requests for.

pub async fn prefetch(&mut self, bytes: Range<u64>)

Prefetches a range of bytes from the remote. When specifying a large range this can drastically reduce the number of requests required to the server.

pub fn len(&self) -> u64

Returns the length of the stream in bytes

Trait Implementations

impl AsyncRead for AsyncHttpRangeReader

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl AsyncSeek for AsyncHttpRangeReader

fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> Result<()>

Attempts to seek to an offset, in bytes, in a stream.

fn poll_complete( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<u64>>

Waits for a seek operation to complete.

impl Debug for AsyncHttpRangeReader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.