Struct pravega_controller_client::ControllerClientImpl

pub struct ControllerClientImpl { /* fields omitted */ }

Implementations

impl ControllerClientImpl

pub fn new(config: ClientConfig, rt: &Runtime) -> Self

Create a pooled connection to the controller. The pool size is decided by the ClientConfig. The requests will be load balanced across multiple connections and every connection supports multiplexing of requests.

pub async fn reset(&self)

reset method needs to be invoked in the case of ConnectionError. This logic can be removed once https://github.com/tower-rs/tower/issues/383 is fixed.

Trait Implementations

impl ControllerClient for ControllerClientImpl

fn create_scope<'life0, 'life1, 'async_trait>(
    &'life0 self,
    scope: &'life1 Scope
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to create a scope. The future completes with true in the case the scope did not exist when the controller executed the operation. In the case of a re-attempt to create the same scope, the future completes with false to indicate that the scope existed when the controller executed the operation.

fn list_streams<'life0, 'life1, 'async_trait>(
    &'life0 self,
    scope: &'life1 Scope
) -> Pin<Box<dyn Future<Output = ResultRetry<Vec<String>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn delete_scope<'life0, 'life1, 'async_trait>(
    &'life0 self,
    scope: &'life1 Scope
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to delete a scope. Note that a scope can only be deleted in the case is it empty. If the scope contains at least one stream, then the delete request will fail.

fn create_stream<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream_config: &'life1 StreamConfiguration
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to create a stream. The future completes with true in the case the stream did not exist when the controller executed the operation. In the case of a re-attempt to create the same stream, the future completes with false to indicate that the stream existed when the controller executed the operation.

fn update_stream<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream_config: &'life1 StreamConfiguration
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to update the configuration of a Stream.

fn truncate_stream<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream_cut: &'life1 StreamCut
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to Truncate stream. This api takes a stream cut point which corresponds to a cut in the stream segments which is consistent and covers the entire key range space.

fn seal_stream<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to seal a Stream.

fn delete_stream<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to delete a stream. Only a sealed stream can be deleted.

fn get_current_segments<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream
) -> Pin<Box<dyn Future<Output = ResultRetry<StreamSegments>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to get list of current segments for the stream to write to.

fn get_epoch_segments<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    epoch: i32
) -> Pin<Box<dyn Future<Output = ResultRetry<StreamSegments>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to get list of segments for a given stream and epoch.

fn get_head_segments<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream
) -> Pin<Box<dyn Future<Output = ResultRetry<ImHashMap<Segment, i64>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to get segments pointing to the HEAD of the stream..

fn create_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    lease: Duration
) -> Pin<Box<dyn Future<Output = ResultRetry<TxnSegments>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to create a new transaction. The transaction timeout is relative to the creation time.

fn ping_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    tx_id: TxId,
    lease: Duration
) -> Pin<Box<dyn Future<Output = ResultRetry<PingStatus>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

API to send transaction heartbeat and increase the transaction timeout by lease amount of milliseconds.

fn commit_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    tx_id: TxId,
    writer_id: WriterId,
    time: Timestamp
) -> Pin<Box<dyn Future<Output = ResultRetry<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Commits a transaction, atomically committing all events to the stream, subject to the ordering guarantees specified in {@link EventStreamWriter}. Will fail if the transaction has already been committed or aborted.

fn abort_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    tx_id: TxId
) -> Pin<Box<dyn Future<Output = ResultRetry<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Aborts a transaction. No events written to it may be read, and no further events may be written. Will fail with if the transaction has already been committed or aborted.

fn check_transaction_status<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    tx_id: TxId
) -> Pin<Box<dyn Future<Output = ResultRetry<TransactionStatus>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Returns the status of the specified transaction.

fn get_endpoint_for_segment<'life0, 'life1, 'async_trait>(
    &'life0 self,
    segment: &'life1 ScopedSegment
) -> Pin<Box<dyn Future<Output = ResultRetry<PravegaNodeUri>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Given a segment return the endpoint that currently is the owner of that segment.

fn get_or_refresh_delegation_token_for<'life0, 'async_trait>(
    &'life0 self,
    stream: ScopedStream
) -> Pin<Box<dyn Future<Output = ResultRetry<String>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Refreshes an expired/non-existent delegation token. @param scope Scope of the stream. @param streamName Name of the stream. @return The delegation token for the given stream.

fn get_successors<'life0, 'life1, 'async_trait>(
    &'life0 self,
    segment: &'life1 ScopedSegment
) -> Pin<Box<dyn Future<Output = ResultRetry<StreamSegmentsWithPredecessors>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Fetch the successors for a given Segment.

fn scale_stream<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    sealed_segment_ids: &'life2 [Segment],
    new_ranges: &'life3 [(f64, f64)]
) -> Pin<Box<dyn Future<Output = ResultRetry<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Scale a Stream to the new key ranges. This API returns a result once the scale operation has completed. This internally uses the check_scale API to verify the Stream Scaling status.

fn check_scale<'life0, 'life1, 'async_trait>(
    &'life0 self,
    stream: &'life1 ScopedStream,
    scale_epoch: i32
) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Check the status of a Stream Scale operation for a given scale epoch. It returns a true if the stream scaling operation has completed and false if the stream scaling is in progress.