Trait pravega_controller_client::ControllerClient

pub trait ControllerClient: Send + Sync {
    // Required methods
    fn create_scope<'life0, 'life1, 'async_trait>(
        &'life0 self,
        scope: &'life1 Scope
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn check_scope_exists<'life0, 'life1, 'async_trait>(
        &'life0 self,
        scope: &'life1 Scope
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_scopes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        token: &'life1 CToken
    ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<(Vec<Scope>, CToken)>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_streams<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        scope: &'life1 Scope,
        token: &'life2 CToken
    ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<(Vec<ScopedStream>, CToken)>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn list_streams_for_tag<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        scope: &'life1 Scope,
        tag: &'life2 str,
        token: &'life3 CToken
    ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<(Vec<ScopedStream>, CToken)>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: '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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn create_stream<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream_config: &'life1 StreamConfiguration
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn check_stream_exists<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_stream<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream_config: &'life1 StreamConfiguration
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_stream_configuration<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream
    ) -> Pin<Box<dyn Future<Output = ResultRetry<StreamConfiguration>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_stream_tags<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream
    ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<Vec<String>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn truncate_stream<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream_cut: &'life1 StreamCut
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn seal_stream<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_stream<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream
    ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_current_segments<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream
    ) -> Pin<Box<dyn Future<Output = ResultRetry<StreamSegments>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_head_segments<'life0, 'life1, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream
    ) -> Pin<Box<dyn Future<Output = ResultRetry<HashMap<Segment, i64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait;
    fn get_successors<'life0, 'life1, 'async_trait>(
        &'life0 self,
        segment: &'life1 ScopedSegment
    ) -> Pin<Box<dyn Future<Output = ResultRetry<StreamSegmentsWithPredecessors>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn scale_stream<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        stream: &'life1 ScopedStream,
        sealed_segments: &'life2 [Segment],
        new_key_ranges: &'life3 [(f64, f64)]
    ) -> Pin<Box<dyn Future<Output = ResultRetry<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}

Controller APIs for administrative action for streams

Required Methods

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 check_scope_exists<'life0, 'life1, 'async_trait>( &'life0 self, scope: &'life1 Scope ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

• API to check if the scope exists. The future completes with true in case the scope exists
• and a false if it does not exist.

fn list_scopes<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 CToken ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<(Vec<Scope>, CToken)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

• API to list scopes given a continuation token..
• Use the pravega_controller_client::paginator::list_scopes to paginate over all the scopes.

fn list_streams<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: &'life1 Scope, token: &'life2 CToken ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<(Vec<ScopedStream>, CToken)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

• API to list streams under a given scope and continuation token.
• Use the pravega_controller_client::paginator::list_streams to paginate over all the streams.

fn list_streams_for_tag<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, scope: &'life1 Scope, tag: &'life2 str, token: &'life3 CToken ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<(Vec<ScopedStream>, CToken)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

• API to list streams associated with the given tag under a given scope and continuation token.
• Use the pravega_controller_client::paginator::list_streams_for_tag to paginate over all the streams.

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 check_stream_exists<'life0, 'life1, 'async_trait>( &'life0 self, stream: &'life1 ScopedStream ) -> Pin<Box<dyn Future<Output = ResultRetry<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

• API to check if the stream exists. The future completes with true in case the stream exists
• and a false if it does not exist.

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

• API to update the configuration of a Stream.

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

• API to fetch the Stream Configuration of a Stream.

fn get_stream_tags<'life0, 'life1, 'async_trait>( &'life0 self, stream: &'life1 ScopedStream ) -> Pin<Box<dyn Future<Output = ResultRetry<Option<Vec<String>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

• API to fetch the Tags for 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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<HashMap<Segment, i64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

• Given a segment return the endpoint that currently is the owner of that segment.
• This is called when a reader or a writer needs to determine which host/server it needs to contact to
• read and write, respectively. The result of this function can be cached until the endpoint is
• unreachable or indicates it is no longer the owner.

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 Self: 'async_trait, 'life0: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch the successors for a given Segment.

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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.

Implementors

impl ControllerClient for MockController

impl ControllerClient for ControllerClientImpl