asynq 0.1.8

Simple, reliable & efficient distributed task queue in Rust, inspired by hibiken/asynq
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

use crate::error::Result;
use serde::{de::DeserializeOwned, Serialize};

#[cfg(feature = "json")]
const CONTENT_TYPE_JSON: &str = "application/json";
#[cfg(feature = "msgpack")]
const CONTENT_TYPE_MSGPACK: &str = "application/msgpack";

/// Generic task payload codec.
pub trait PayloadCodec {
  /// Content-Type represented by this codec.
  fn content_type(&self) -> &'static str;

  /// Encode a serializable value to bytes.
  fn encode<T: Serialize>(&self, value: &T) -> Result<Vec<u8>>;

  /// Decode bytes into the target type.
  fn decode<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T>;
}

/// JSON payload codec.
#[cfg(feature = "json")]
#[derive(Debug, Clone, Copy, Default)]
pub struct JsonPayloadCodec;

#[cfg(feature = "json")]
impl PayloadCodec for JsonPayloadCodec {
  fn content_type(&self) -> &'static str {
    CONTENT_TYPE_JSON
  }

  fn encode<T: Serialize>(&self, value: &T) -> Result<Vec<u8>> {
    serde_json::to_vec(value).map_err(|e| crate::error::Error::Serialization(e.to_string()))
  }

  fn decode<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T> {
    serde_json::from_slice(bytes).map_err(|e| crate::error::Error::Deserialization(e.to_string()))
  }
}

/// MsgPack payload codec.
#[cfg(feature = "msgpack")]
#[derive(Debug, Clone, Copy, Default)]
pub struct MsgPackPayloadCodec;

#[cfg(feature = "msgpack")]
impl PayloadCodec for MsgPackPayloadCodec {
  fn content_type(&self) -> &'static str {
    CONTENT_TYPE_MSGPACK
  }

  fn encode<T: Serialize>(&self, value: &T) -> Result<Vec<u8>> {
    use rmp_serde::Serializer;

    let mut payload = Vec::new();
    value
      .serialize(&mut Serializer::new(&mut payload))
      .map_err(|e| crate::error::Error::Serialization(e.to_string()))?;
    Ok(payload)
  }

  fn decode<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T> {
    rmp_serde::from_slice(bytes).map_err(|e| crate::error::Error::Deserialization(e.to_string()))
  }
}