Struct pravega_client::event::EventWriter

pub struct EventWriter { /* private fields */ }

Write events exactly once to a given stream.

EventWriter spawns a Reactor that runs in the background for processing incoming events. The write method sends the event to the Reactor asynchronously and returns a tokio::oneshot::Receiver which contains the result of the write to the caller. The maximum size of the serialized event supported is 8MB, writing size larger than that will return an error.

Backpressure

Write has a backpressure mechanism. Internally, it uses Channel to send event to Reactor for processing. Channel has a limited capacity, when its capacity is reached, any further write will not be accepted until enough space has been freed in the Channel.

Retry

The EventWriter implementation provides retry logic to handle connection failures and service host failures. Internal retries will not violate the exactly once semantic so it is better to rely on them than to wrap this with custom retry logic.

Examples

use pravega_client_config::ClientConfigBuilder;
use pravega_client::client_factory::ClientFactory;
use pravega_client_shared::ScopedStream;

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

    let client_factory = ClientFactory::new(config);

    // assuming scope:myscope and stream:mystream has been created before.
    let stream = ScopedStream::from("myscope/mystream");

    let mut event_writer = client_factory.create_event_writer(stream);

    let payload = "hello world".to_string().into_bytes();
    let result = event_writer.write_event(payload).await;

    assert!(result.await.is_ok())
}

Implementations

impl EventWriter

pub async fn write_event( &mut self, event: Vec<u8> ) -> Receiver<Result<(), Error>>

Write an event without routing key.

A random routing key will be generated in this case.

This method sends the payload to a background task called reactor to process, so the success of this method only means the payload has been sent to the reactor. Applications may want to call await on the returned tokio oneshot to check whether the payload is successfully persisted or not. If oneshot returns an error indicating something is going wrong on the server side, then subsequent calls are also likely to fail.

Examples

let mut event_writer = client_factory.create_event_writer(stream);
// result is a tokio oneshot
let result = event_writer.write_event(payload).await;
result.await.expect("flush to server");

pub async fn write_event_by_routing_key( &mut self, routing_key: String, event: Vec<u8> ) -> Receiver<Result<(), Error>>

Writes an event with a routing key.

Same as the write_event.

pub async fn flush(&mut self) -> Result<(), Error>

Flush data.

It will wait until all pending appends have acknowledgment.

Trait Implementations

impl Drop for EventWriter

fn drop(&mut self)

Executes the destructor for this type.