Struct ConcurrentTasks

Source
pub struct ConcurrentTasks<I, O> { /* private fields */ }
Expand description

ConcurrentTasks is used to execute tasks concurrently.

ConcurrentTasks has two generic types:

  • I represents the input type of the task.
  • O represents the output type of the task.

§Implementation Notes

The code patterns below are intentional; please do not modify them unless you fully understand these notes.

 let (i, o) = self
    .tasks
    .front_mut()                                        // Use `front_mut` instead of `pop_front`
    .expect("tasks must be available")
    .await;
...
match o {
    Ok(o) => {
        let _ = self.tasks.pop_front();                 // `pop_front` after got `Ok(o)`
        self.results.push_back(o)
    }
    Err(err) => {
        if err.is_temporary() {
            let task = self.create_task(i);
            self.tasks
                .front_mut()
                .expect("tasks must be available")
                .replace(task)                          // Use replace here to instead of `push_front`
        } else {
            self.clear();
            self.errored = true;
        }
        return Err(err);
    }
}

Please keep in mind that there is no guarantee the task will be awaited until completion. It’s possible the task may be dropped before it resolves. Therefore, we should keep the Task in the tasks queue until it is resolved.

For example, users may have a timeout for the task, and the task will be dropped if it exceeds the timeout. If we pop_front the task before it resolves, the task will be canceled and the result will be lost.

Implementations§

Source§

impl<I: Send + 'static, O: Send + 'static> ConcurrentTasks<I, O>

Source

pub fn new( executor: Executor, concurrent: usize, factory: fn(I) -> BoxedStaticFuture<(I, Result<O>)>, ) -> Self

Create a new concurrent tasks with given executor, concurrent and factory.

The factory is a function pointer that shouldn’t capture any context.

Source

pub fn clear(&mut self)

Clear all tasks and results.

All ongoing tasks will be canceled.

Source

pub fn has_remaining(&self) -> bool

Check if there are remaining space to push new tasks.

Source

pub fn has_result(&self) -> bool

Chunk if there are remaining results to fetch.

Source

pub fn create_task(&self, input: I) -> Task<(I, Result<O>)>

Create a task with given input.

Source

pub async fn execute(&mut self, input: I) -> Result<()>

Execute the task with given input.

  • Execute the task in the current thread if is not concurrent.
  • Execute the task in the background if there are available slots.
  • Await the first task in the queue if there is no available slots.
Source

pub async fn next(&mut self) -> Option<Result<O>>

Fetch the successful result from the result queue.

Auto Trait Implementations§

§

impl<I, O> Freeze for ConcurrentTasks<I, O>

§

impl<I, O> !RefUnwindSafe for ConcurrentTasks<I, O>

§

impl<I, O> Send for ConcurrentTasks<I, O>
where O: Send, I: Send,

§

impl<I, O> Sync for ConcurrentTasks<I, O>
where O: Sync + Send, I: Send,

§

impl<I, O> Unpin for ConcurrentTasks<I, O>
where O: Unpin,

§

impl<I, O> !UnwindSafe for ConcurrentTasks<I, O>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ServiceExt for T

Source§

fn map_response_body<F>(self, f: F) -> MapResponseBody<Self, F>
where Self: Sized,

Apply a transformation to the response body. Read more
Source§

fn decompression(self) -> Decompression<Self>
where Self: Sized,

Decompress response bodies. Read more
Source§

fn trace_for_http(self) -> Trace<Self, SharedClassifier<ServerErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using HTTP status codes. Read more
Source§

fn trace_for_grpc(self) -> Trace<Self, SharedClassifier<GrpcErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using gRPC headers. Read more
Source§

fn follow_redirects(self) -> FollowRedirect<Self>
where Self: Sized,

Follow redirect resposes using the Standard policy. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> MaybeSend for T
where T: Send,