Struct fang::asynk::async_queue::AsyncQueue

pub struct AsyncQueue<Tls>where
    Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static,
    <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync,
    <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send,
    <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,{ /* private fields */ }

An async queue that can be used to enqueue tasks. It uses a PostgreSQL storage. It must be connected to perform any operation. To connect an AsyncQueue to PostgreSQL database call the connect method. A Queue can be created with the TypedBuilder.

     let mut queue = AsyncQueue::builder()
         .uri("postgres://postgres:postgres@localhost/fang")
         .max_pool_size(max_pool_size)
         .build();

Implementations

impl<Tls> AsyncQueue<Tls>where Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static, <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync, <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send, <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,

pub fn builder() -> AsyncQueueBuilder<Tls, ((), ())>

Create a builder for building AsyncQueue. On the builder, call .uri(...), .max_pool_size(...) to set the values of the fields. Finally, call .build() to create the instance of AsyncQueue.

impl<Tls> AsyncQueue<Tls>where Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static, <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync, <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send, <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,

pub fn check_if_connection(&self) -> Result<(), AsyncQueueError>

Check if the connection with db is established

pub async fn connect(&mut self, tls: Tls) -> Result<(), AsyncQueueError>

Connect to the db if not connected

Trait Implementations

impl<Tls> AsyncQueueable for AsyncQueue<Tls>where Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static, <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync, <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send, <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,

fn find_task_by_id<'life0, 'async_trait>( &'life0 mut self, id: Uuid ) -> Pin<Box<dyn Future<Output = Result<Task, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a task from storage by its id.

fn fetch_and_touch_task<'life0, 'async_trait>( &'life0 mut self, task_type: Option<String> ) -> Pin<Box<dyn Future<Output = Result<Option<Task>, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

This method should retrieve one task of the task_type type. If task_type is None it will try to fetch a task of the type common. After fetching it should update the state of the task to FangTaskState::InProgress.

fn insert_task<'life0, 'life1, 'async_trait>( &'life0 mut self, task: &'life1 dyn AsyncRunnable ) -> Pin<Box<dyn Future<Output = Result<Task, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Enqueue a task to the queue, The task will be executed as soon as possible by the worker of the same type created by an AsyncWorkerPool.

fn schedule_task<'life0, 'life1, 'async_trait>( &'life0 mut self, task: &'life1 dyn AsyncRunnable ) -> Pin<Box<dyn Future<Output = Result<Task, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Schedule a task.

fn remove_all_tasks<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<u64, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

The method will remove all tasks from the queue

fn remove_all_scheduled_tasks<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<u64, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Remove all tasks that are scheduled in the future.

fn remove_task<'life0, 'async_trait>( &'life0 mut self, id: Uuid ) -> Pin<Box<dyn Future<Output = Result<u64, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Remove a task by its id.

fn remove_task_by_metadata<'life0, 'life1, 'async_trait>( &'life0 mut self, task: &'life1 dyn AsyncRunnable ) -> Pin<Box<dyn Future<Output = Result<u64, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a task by its metadata (struct fields values)

fn remove_tasks_type<'life0, 'life1, 'async_trait>( &'life0 mut self, task_type: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<u64, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Removes all tasks that have the specified task_type.

fn update_task_state<'life0, 'async_trait>( &'life0 mut self, task: Task, state: FangTaskState ) -> Pin<Box<dyn Future<Output = Result<Task, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Update the state field of the specified task See the FangTaskState enum for possible states.

fn fail_task<'life0, 'life1, 'async_trait>( &'life0 mut self, task: Task, error_message: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Task, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update the state of a task to FangTaskState::Failed and set an error_message.

fn schedule_retry<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, task: &'life1 Task, backoff_seconds: u32, error: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Task, AsyncQueueError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl<Tls> Clone for AsyncQueue<Tls>where Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static + Clone, <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync, <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send, <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,

fn clone(&self) -> AsyncQueue<Tls>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tls> Debug for AsyncQueue<Tls>where Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static + Debug, <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync, <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send, <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,

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

Formats the value using the given formatter.