Struct pravega_client::event::ReaderGroup

pub struct ReaderGroup {
    pub name: String,
    pub config: ReaderGroupConfig,
    /* private fields */
}

A collection of readers that collectively read all the events in the stream.

The events are distributed among the readers in the group such that each event goes to only one reader.

The readers in the group may change over time. Readers are added to the group by invoking the ReaderGroup::create_reader API.

Examples

use pravega_client_config::ClientConfigBuilder;
use pravega_client::client_factory::ClientFactory;
use pravega_client_shared::{ScopedStream, Scope, Stream};

#[tokio::main]
async fn main() {
   let config = ClientConfigBuilder::default()
        .controller_uri("localhost:8000")
        .build()
        .expect("creating config");
    let client_factory = ClientFactory::new(config);
    let stream = ScopedStream {
        scope: Scope::from("scope".to_string()),
        stream: Stream::from("stream".to_string()),
    };
    // Create a reader group to read data from the Pravega stream.
    let rg = client_factory.create_reader_group("rg".to_string(), stream).await;
    // Create a reader under the reader group.
    let mut reader1 = rg.create_reader("r1".to_string()).await;
    let mut reader2 = rg.create_reader("r2".to_string()).await;
    // EventReader APIs can be used to read events.
}

Fields

name: String

config: ReaderGroupConfig

Implementations

impl ReaderGroup

pub async fn create_reader(&self, reader_id: String) -> EventReader

Create a new EventReader under the ReaderGroup. This method panics if the reader is already part of the reader group.

Examples

let rg = client_factory.create_reader_group(scope, "rg".to_string(), stream).await;
let reader = rg.create_reader("reader".to_string()).await;

pub async fn list_readers(&self) -> Vec<Reader>

Returns the readers which are currently online.

pub async fn reader_offline( &self, reader_id: String, last_position: Option<HashMap<String, i64>> ) -> Result<(), ReaderGroupStateError>

Removes a reader from the reader group. (Because it is offline) Normally, readers shutdown gracefully by calling reader_offline on the reader itself. However, if the process dies, this provides an alternative way to shutdown the reader.

last_position is a map containing the last offsets processed by the reader. There is no requirement for the map to be complete, or even non-empty. If a segment is missing, the last known value will be assumed.

The application can persist the full scoped segment and offset by using the SegmentSlice and the Event obtained while iterating over the SegmentSlice.

If the reader is already offline, this method will have no effect.

pub fn get_managed_streams(&self) -> Vec<ScopedStream>

Return the managed Streams by the ReaderGroup.

pub async fn get_streamcut(&self) -> StreamCut

Return the latest StreamCut in ReaderGroup.