Struct pravega_client::byte::reader::ByteReader

pub struct ByteReader {
    pub segment: ScopedSegment,
    /* private fields */
}

A ByteReader enables reading raw bytes from a segment.

The ByteReader provides an API similar to the Read and Seek traits in the standard library, but where the methods are asynchronous.

Internally ByteReader uses a prefetching reader that prefetches data from the server in the background. The prefetched data is cached in memory so any sequential reads should be able to hit the cache.

Any seek operation will invalidate the cache and causes cache miss, so frequent seek and read operations might not have good performance.

You can also wrap ByteReader with BufReader, but doing so will not increase performance further.

Examples

use pravega_client_config::ClientConfigBuilder;
use pravega_client::client_factory::ClientFactoryAsync;
use pravega_client_shared::ScopedStream;
use tokio::runtime::Handle;

#[tokio::main]
async fn main() {
    // assuming Pravega controller is running at endpoint `localhost:9090`
    let config = ClientConfigBuilder::default()
        .controller_uri("localhost:9090")
        .build()
        .expect("creating config");

    let handle = Handle::current();
    let client_factory = ClientFactoryAsync::new(config, handle);

    // assuming scope:myscope, stream:mystream exist.
    // notice that this stream should be a fixed sized single segment stream
    let stream = ScopedStream::from("myscope/mystream");

    let mut byte_reader = client_factory.create_byte_reader(stream).await;
    let mut buf: Vec<u8> = vec![0; 4];
    let size = byte_reader.read(&mut buf).await.expect("read from byte stream");
}

Fields

segment: ScopedSegment

Implementations

impl ByteReader

pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Read data asynchronously.

let mut byte_reader = client_factory.create_byte_reader(segment).await;
let mut buf: Vec<u8> = vec![0; 4];
let size = byte_reader.read(&mut buf).expect("read");

pub async fn current_head(&self) -> Result<u64>

Return the head of current readable data in the segment asynchronously.

The ByteReader is initialized to read from the segment at offset 0. However, it might encounter the SegmentIsTruncated error due to the segment has been truncated. In this case, application should call this method to get the current readable head and read from it.

let mut byte_reader = client_factory.create_byte_reader_async(segment).await;
let offset = byte_reader.current_head().await.expect("get current head offset");

pub async fn current_tail(&self) -> Result<u64>

Return the tail offset of the segment asynchronously.

let mut byte_reader = client_factory.create_byte_reader_async(segment).await;
let offset = byte_reader.current_tail().await.expect("get current tail offset");

pub fn current_offset(&self) -> u64

Return the current read offset.

let mut byte_reader = client_factory.create_byte_reader(segment);
let offset = byte_reader.current_offset();

pub fn available(&self) -> usize

Return the bytes that are available to read instantly without fetching from server.

ByteReader has a buffer internally. This method returns the size of remaining data in that buffer.

let mut byte_reader = client_factory.create_byte_reader(segment);
let size = byte_reader.available();

pub async fn seek(&mut self, pos: SeekFrom) -> Result<u64>

The seek method for ByteReader allows seeking to a byte offset from the beginning of the stream or a byte offset relative to the current position in the stream. If the stream has been truncated, the byte offset will be relative to the original beginning of the stream.