Struct pravega_client::client_factory::ClientFactory

pub struct ClientFactory { /* private fields */ }

Applications should use ClientFactory to create resources they need.

ClientFactory contains a connection pool that is shared by all the readers and writers it creates. It also contains a tokio runtime that is used to drive async tasks. Spawned tasks in readers and writers are tied to this runtime.

Note that dropping Runtime in async context is not a good practice and it will have warning messages. ClientFactory is the only place that’s holding the Runtime, so it should not be used in any async contexts. You can use [‘ClientFactoryAsync’] in async contexts instead.

Examples

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

fn main() {
   let config = ClientConfigBuilder::default()
        .controller_uri("localhost:8000")
        .build()
        .expect("create config");
    let client_factory = ClientFactory::new(config);
}

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

#[tokio::main]
async fn main() {
   let config = ClientConfigBuilder::default()
        .controller_uri("localhost:8000")
        .build()
        .expect("create config");
    let handle = Handle::try_current().expect("get current runtime handle");
    let client_factory = ClientFactoryAsync::new(config, handle);
}

Implementations

impl ClientFactory

pub fn new(config: ClientConfig) -> ClientFactory

pub fn new_with_runtime(config: ClientConfig, rt: Runtime) -> ClientFactory

pub fn runtime(&self) -> &Runtime

pub fn runtime_handle(&self) -> Handle

pub fn config(&self) -> &ClientConfig

pub fn controller_client(&self) -> &dyn ControllerClient

pub fn create_event_writer(&self, stream: ScopedStream) -> EventWriter

pub async fn create_reader_group( &self, reader_group_name: String, stream: ScopedStream ) -> ReaderGroup

pub async fn create_reader_group_with_config( &self, reader_group_name: String, reader_group_config: ReaderGroupConfig, scope: Scope ) -> ReaderGroup

Create a Reader Group based on the ReaderGroupConfig.

pub async fn delete_reader_group( &self, scope: Scope, reader_group_name: String ) -> Result<(), TableError>

Delete a ReaderGroup.

pub async fn create_transactional_event_writer( &self, stream: ScopedStream, writer_id: WriterId ) -> TransactionalEventWriter

pub async fn create_byte_writer(&self, stream: ScopedStream) -> ByteWriter

pub async fn create_byte_reader(&self, stream: ScopedStream) -> ByteReader

pub async fn create_index_writer<T: Fields + PartialOrd + PartialEq + Debug>( &self, stream: ScopedStream ) -> IndexWriter<T>

pub async fn create_index_reader(&self, stream: ScopedStream) -> IndexReader

pub async fn create_table(&self, scope: Scope, name: String) -> Table

pub async fn create_synchronizer( &self, scope: Scope, name: String ) -> Synchronizer

pub fn to_async(&self) -> ClientFactoryAsync