Struct BasicRetryWorker

pub struct BasicRetryWorker<R> {
    pub request: R,
    pub retries: usize,
}

A basic worker which can retry on failure

Fields

request: R

The worker’s request

retries: usize

The number of times this worker will retry on failure

Implementations

impl<R> BasicRetryWorker<R>

pub fn new(request: R) -> Box<Self>

Create a new insert worker with a number of retries

Trait Implementations

impl<R> Clone for BasicRetryWorker<R>

where R: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R> Debug for BasicRetryWorker<R>

where R: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R> From<R> for BasicRetryWorker<R>

fn from(request: R) -> Self

Converts to this type from the input type.

impl<R, H> IntoRespondingWorker<R, H> for BasicRetryWorker<R>

where H: 'static + Debug + Send + Sync, R: 'static + Send + Debug + Request + Sync + SendRequestExt,

type Output = AnyWorker<H, R>

The type of worker which will be created

fn with_handle(self, handle: H) -> AnyWorker<H, R>

Give the worker a handle

impl<R> RetryableWorker<R> for BasicRetryWorker<R>

where R: 'static + Debug + Send + Request + Sync,

fn retries(&self) -> usize

Get the number of retries remaining

fn request(&self) -> &R

Get the request

fn retries_mut(&mut self) -> &mut usize

Mutably access the number of retries remaining

fn with_retries(self, retries: usize) -> Self

where Self: Sized + Into<Box<Self>>,

Update the retry count

fn retry(self) -> Result<Option<Box<Self>>>

where Self: 'static + Sized + Into<Box<Self>> + Worker, R: Request,

Retry the worker

fn send_to_reporter( self: Box<Self>, reporter: &ReporterHandle, ) -> Result<DecodeResult<R::Marker>, RequestError>

where Self: 'static + Sized + Worker, R: SendRequestExt,

Send the worker to a specific reporter, without waiting for a response

fn send_local(self) -> Result<DecodeResult<R::Marker>, RequestError>

where Self: 'static + Sized + Into<Box<Self>> + Worker, R: SendRequestExt,

Send the worker to the local datacenter, without waiting for a response

fn send_global(self) -> Result<DecodeResult<R::Marker>, RequestError>

where Self: 'static + Sized + Into<Box<Self>> + Worker, R: SendRequestExt,

Send the worker to a global datacenter, without waiting for a response

fn get_local<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<<R::Marker as Marker>::Output, RequestError>> + Send + 'async_trait>>

where R: SendRequestExt, Self: 'static + IntoRespondingWorker<R, Sender<Result<Decoder, WorkerError>>, Decoder> + Into<Box<Self>> + Send + 'async_trait, Self::Output: RetryableWorker<R> + Worker, R::Marker: Send + Sync,

Send the worker to the local datacenter and await a response asynchronously

fn get_local_blocking( self, ) -> Result<<R::Marker as Marker>::Output, RequestError>

where R: SendRequestExt, Self: 'static + IntoRespondingWorker<R, Sender<Result<Decoder, WorkerError>>, Decoder> + Into<Box<Self>>, Self::Output: RetryableWorker<R> + Worker,

Send the worker to the local datacenter and await a response synchronously

fn get_global<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<<R::Marker as Marker>::Output, RequestError>> + Send + 'async_trait>>

where R: SendRequestExt, Self: 'static + IntoRespondingWorker<R, Sender<Result<Decoder, WorkerError>>, Decoder> + Into<Box<Self>> + Send + 'async_trait, Self::Output: RetryableWorker<R> + Worker, R::Marker: Send + Sync,

Send the worker to a global datacenter and await a response asynchronously

fn get_global_blocking( self, ) -> Result<<R::Marker as Marker>::Output, RequestError>

where R: SendRequestExt, Self: 'static + IntoRespondingWorker<R, Sender<Result<Decoder, WorkerError>>, Decoder> + Into<Box<Self>>, Self::Output: RetryableWorker<R> + Worker,

Send the worker to a global datacenter and await a response synchronously

impl<R> Worker for BasicRetryWorker<R>

where R: 'static + Debug + Send + Request + Sync,

fn handle_response(self: Box<Self>, giveload: Vec<u8>) -> Result<()>

Reporter will invoke this method to Send the cql response to worker

fn handle_error( self: Box<Self>, error: WorkerError, reporter_opt: Option<&ReporterHandle>, ) -> Result<()>

Reporter will invoke this method to Send the worker error to worker