Struct disque::Disque

pub struct Disque { /* fields omitted */ }

Methods

impl Disque

fn open<T: IntoConnectionInfo>(params: T) -> RedisResult<Disque>

Opens a new connection to a Disque server.

Examples

let disque = Disque::open("redis://127.0.0.1:7711/").unwrap();

fn hello(&self) -> RedisResult<(u8, String, Vec<(String, String, u16, u32)>)>

The hello command returns information about the disque cluster.

Examples

let disque = Disque::open("redis://127.0.0.1:7711/").unwrap();
let (_, nodeid, _) = disque.hello().unwrap();
println!("Connected to node {}", nodeid);

fn addjob(
    &self,
    queue_name: &[u8],
    job: &[u8],
    timeout: Duration,
    replicate: Option<usize>,
    delay: Option<Duration>,
    retry: Option<Duration>,
    ttl: Option<Duration>,
    maxlen: Option<usize>,
    async: bool
) -> RedisResult<String>

Adds a job to a queue.

Examples

let disque = Disque::open("redis://127.0.0.1:7711/").unwrap();
let jobid = disque.addjob(b"my queue", b"my job",
  Duration::from_secs(10), None, None, None, None, None, false
  ).unwrap();
println!("My job id is {}", jobid);

fn getjob_count(
    &self,
    nohang: bool,
    timeout: Option<Duration>,
    count: usize,
    queues: &[&[u8]]
) -> RedisResult<Vec<(Vec<u8>, String, Vec<u8>)>>

Gets up to count jobs from certain queues.

Examples

let disque = Disque::open("redis://127.0.0.1:7711/").unwrap();
let queue = b"my getjob_count queue";
disque.addjob(queue, b"my job 1", Duration::from_secs(10),
  None, None, None, None, None, false
  ).unwrap();
disque.addjob(queue, b"my job 2", Duration::from_secs(10),
  None, None, None, None, None, false
  ).unwrap();

let jobs = disque.getjob_count(true, None, 10, &[queue]).unwrap();
assert_eq!(jobs.len(), 2);
assert_eq!(jobs[0].2, b"my job 1");
assert_eq!(jobs[1].2, b"my job 2");

fn getjob_count_withcounters(
    &self,
    nohang: bool,
    timeout: Option<Duration>,
    count: usize,
    queues: &[&[u8]]
) -> RedisResult<Vec<(Vec<u8>, String, Vec<u8>, u32, u32)>>

fn getjob(
    &self,
    nohang: bool,
    timeout: Option<Duration>,
    queues: &[&[u8]]
) -> RedisResult<Option<(Vec<u8>, String, Vec<u8>)>>

Gets a single job from any of the specified queues.

fn getjob_withcounters(
    &self,
    nohang: bool,
    timeout: Option<Duration>,
    queues: &[&[u8]]
) -> RedisResult<Option<(Vec<u8>, String, Vec<u8>, u32, u32)>>

Gets a single job from any of the specified queues with its nack and additional deliveries count.

fn ackjobs(&self, jobids: &[&[u8]]) -> RedisResult<usize>

Acknowledge jobs.

fn ackjob(&self, jobid: &[u8]) -> RedisResult<bool>

Acknowledge a job.

fn fastackjobs(&self, jobids: &[&[u8]]) -> RedisResult<usize>

Fast acknowledge jobs.

fn fastackjob(&self, jobid: &[u8]) -> RedisResult<bool>

Fast acknowledge a job.

fn working(&self, jobid: &[u8]) -> RedisResult<Duration>

Tell Disque that a job is still processed.

fn nackjobs(&self, jobids: &[&[u8]]) -> RedisResult<usize>

Tells Disque to put back the jobs in the queue ASAP. Should be used when the worker was not able to process a message and wants the message to be put back into the queue in order to be processed again.

fn nackjob(&self, jobid: &[u8]) -> RedisResult<bool>

Tells Disque to put back a job in the queue ASAP.

fn info(&self) -> RedisResult<InfoDict>

Information about the server

fn qlen(&self, queue_name: &[u8]) -> RedisResult<usize>

Size of the queue

fn qpeek(&self, queue_name: &[u8], count: i64) -> RedisResult<Vec<Vec<Vec<u8>>>>

Gets jobs from queue_name up to the absolute number of count. If count is negative, it will be from newest to oldest.

fn enqueue(&self, jobids: &[&[u8]]) -> RedisResult<usize>

Add jobs to queues

fn dequeue(&self, jobids: &[&[u8]]) -> RedisResult<usize>

Remove jobs from queue

fn deljobs(&self, jobids: &[&[u8]]) -> RedisResult<usize>

Completely delete jobs from a single node.

fn deljob(&self, jobid: &[u8]) -> RedisResult<bool>

Completely delete a job from a single node.

fn show(&self, jobid: &[u8]) -> RedisResult<Option<HashMap<String, Value>>>

Returns full information about a job, like its current state and data.

fn qscan(
    &self,
    cursor: u64,
    count: u64,
    busyloop: bool,
    minlen: Option<u64>,
    maxlen: Option<u64>,
    importrate: Option<u64>
) -> RedisResult<Iter<Vec<u8>>>

Iterator to run all queues that fulfil a criteria. The iterator will batch into segments of approximate count size.

fn jscan_id(
    &self,
    cursor: u64,
    count: u64,
    busyloop: bool,
    queue: Option<&[u8]>,
    states: &[&str]
) -> RedisResult<Iter<String>>

Iterator for all job ids that fulfil a criteria. The iterator will batch into segments of approximate count size.

fn jscan_all(
    &self,
    cursor: u64,
    count: u64,
    busyloop: bool,
    queue: Option<&[u8]>,
    states: &[&str]
) -> RedisResult<Iter<HashMap<String, Value>>>

Iterator for all jobs that fulfil a criteria. The iterator will batch into segments of approximate count size.