faktory 0.13.1

API bindings for the language-agnostic Faktory work server
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use std::io;
use tokio::io::BufStream;
use tokio::io::{AsyncRead, AsyncWrite};
use tokio::net::TcpStream as TokioStream;

mod client;
pub(crate) use client::{
    BoxedConnection, ClientOptions, HeartbeatStatus, EXPECTED_PROTOCOL_VERSION,
};
pub use client::{Client, Connection};

mod single;

pub use single::{
    DataSnapshot, Failure, FaktoryState, Job, JobBuilder, JobId, ServerSnapshot, WorkerId,
};

pub use single::mutation::{Filter, JobSet};

pub(crate) use single::{Ack, Fail, Info, Push, PushBulk, QueueAction, QueueControl};

pub(crate) mod utils;

#[cfg(feature = "ent")]
pub use self::single::ent::{JobState, Progress, ProgressUpdate, ProgressUpdateBuilder};

#[cfg(feature = "ent")]
pub(crate) use self::single::ent::FetchProgress;

#[cfg(feature = "ent")]
pub use self::single::BatchId;

#[cfg(feature = "ent")]
mod batch;
#[cfg(feature = "ent")]
pub use batch::{Batch, BatchBuilder, BatchHandle, BatchStatus, CallbackState};

/// A stream that can be re-established after failing.
#[async_trait::async_trait]
pub trait Reconnect {
    /// Re-establish the stream.
    async fn reconnect(&mut self) -> io::Result<BoxedConnection>;
}

#[async_trait::async_trait]
impl<S> Reconnect for Box<S>
where
    S: Reconnect + Send,
{
    async fn reconnect(&mut self) -> io::Result<BoxedConnection> {
        (**self).reconnect().await
    }
}

#[async_trait::async_trait]
impl Reconnect for TokioStream {
    async fn reconnect(&mut self) -> io::Result<BoxedConnection> {
        let addr = &self.peer_addr().expect("socket address");
        let stream = TokioStream::connect(addr).await?;
        Ok(Box::new(BufStream::new(stream)))
    }
}

#[async_trait::async_trait]
impl<S> Reconnect for BufStream<S>
where
    S: AsyncRead + AsyncWrite + Reconnect + Send + Sync,
{
    async fn reconnect(&mut self) -> io::Result<BoxedConnection> {
        self.get_mut().reconnect().await
    }
}