Struct Queue

pub struct Queue { /* private fields */ }

Implementations

impl Queue

pub fn new(redis_client: RedisClient, prefetch: i32) -> Queue

Examples found in repository

examples/consume.rs (line 14)

async fn main() -> Result<()> {
    let redis = RedisClient::new().await?;
    let mut queue = Queue::new(redis, 10);

    let _t2 = tokio::spawn({
        let mut q = queue.clone();

        async move {
            let mut i: i32 = 0;
            loop {
                let job = Job { id: format!("{i}") };
                i += 1;

                q.publish(&job).await.unwrap();
                sleep(Duration::from_millis(5)).await;
            }
        }
    });

    let consumers: Vec<_> = (1..50)
        .into_iter()
        .map(|i| {
            let mut consumer = queue.new_consumer();

            tokio::spawn({
                async move {
                    loop {
                        let job = consumer.fetch_task().await;
                        println!("consumer_id: {}, consumed job {:?}", i, job)
                    }
                }
            })
        })
        .collect();

    queue.start().await?;
    try_join_all(consumers).await?;

    Ok(())
}

pub async fn start(&mut self) -> Result<()>

Examples found in repository

examples/consume.rs (line 47)

async fn main() -> Result<()> {
    let redis = RedisClient::new().await?;
    let mut queue = Queue::new(redis, 10);

    let _t2 = tokio::spawn({
        let mut q = queue.clone();

        async move {
            let mut i: i32 = 0;
            loop {
                let job = Job { id: format!("{i}") };
                i += 1;

                q.publish(&job).await.unwrap();
                sleep(Duration::from_millis(5)).await;
            }
        }
    });

    let consumers: Vec<_> = (1..50)
        .into_iter()
        .map(|i| {
            let mut consumer = queue.new_consumer();

            tokio::spawn({
                async move {
                    loop {
                        let job = consumer.fetch_task().await;
                        println!("consumer_id: {}, consumed job {:?}", i, job)
                    }
                }
            })
        })
        .collect();

    queue.start().await?;
    try_join_all(consumers).await?;

    Ok(())
}

pub fn new_consumer(&mut self) -> Consumer

Examples found in repository

examples/consume.rs (line 34)

async fn main() -> Result<()> {
    let redis = RedisClient::new().await?;
    let mut queue = Queue::new(redis, 10);

    let _t2 = tokio::spawn({
        let mut q = queue.clone();

        async move {
            let mut i: i32 = 0;
            loop {
                let job = Job { id: format!("{i}") };
                i += 1;

                q.publish(&job).await.unwrap();
                sleep(Duration::from_millis(5)).await;
            }
        }
    });

    let consumers: Vec<_> = (1..50)
        .into_iter()
        .map(|i| {
            let mut consumer = queue.new_consumer();

            tokio::spawn({
                async move {
                    loop {
                        let job = consumer.fetch_task().await;
                        println!("consumer_id: {}, consumed job {:?}", i, job)
                    }
                }
            })
        })
        .collect();

    queue.start().await?;
    try_join_all(consumers).await?;

    Ok(())
}

pub async fn publish(&mut self, job: &Job) -> Result<()>

Examples found in repository

examples/consume.rs (line 25)

async fn main() -> Result<()> {
    let redis = RedisClient::new().await?;
    let mut queue = Queue::new(redis, 10);

    let _t2 = tokio::spawn({
        let mut q = queue.clone();

        async move {
            let mut i: i32 = 0;
            loop {
                let job = Job { id: format!("{i}") };
                i += 1;

                q.publish(&job).await.unwrap();
                sleep(Duration::from_millis(5)).await;
            }
        }
    });

    let consumers: Vec<_> = (1..50)
        .into_iter()
        .map(|i| {
            let mut consumer = queue.new_consumer();

            tokio::spawn({
                async move {
                    loop {
                        let job = consumer.fetch_task().await;
                        println!("consumer_id: {}, consumed job {:?}", i, job)
                    }
                }
            })
        })
        .collect();

    queue.start().await?;
    try_join_all(consumers).await?;

    Ok(())
}

Trait Implementations

impl Clone for Queue

fn clone(&self) -> Queue

Returns a copy of the value.

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

Performs copy-assignment from source.