atomr-remote 0.1.0

Cross-process and cross-host actor messaging for atomr — TCP transport, framed PDU codec, ack'd delivery, endpoint state machine, watcher.
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

//! Bincode v2 + serde codec helpers.

use serde::{de::DeserializeOwned, Serialize};

use super::{SerializeError, SerializerRegistry, BINCODE_SERIALIZER_ID, SYSTEM_SERIALIZER_ID};
use crate::pdu::{AckInfo, AssociateInfo, DisassociateReason};

pub fn bincode_encode<T: Serialize>(value: &T) -> Result<Vec<u8>, SerializeError> {
    bincode::serde::encode_to_vec(value, bincode::config::standard())
        .map_err(|e| SerializeError::Encode(e.to_string()))
}

pub fn bincode_decode<T: DeserializeOwned>(bytes: &[u8]) -> Result<T, SerializeError> {
    let (v, _) = bincode::serde::decode_from_slice(bytes, bincode::config::standard())
        .map_err(|e| SerializeError::Decode(e.to_string()))?;
    Ok(v)
}

/// System control payloads use the same bincode codec but a reserved
/// `serializer_id` of [`SYSTEM_SERIALIZER_ID`] so receivers can dispatch
/// them on the system path without consulting the user manifest table.
pub fn system_encode<T: Serialize>(value: &T) -> Result<Vec<u8>, SerializeError> {
    bincode_encode(value)
}

pub fn system_decode<T: DeserializeOwned>(bytes: &[u8]) -> Result<T, SerializeError> {
    bincode_decode(bytes)
}

/// Pre-register codecs for the protocol-level system payloads
/// (`AssociateInfo`, `DisassociateReason`, `AckInfo`, plus the
/// `RemoteSystemMsg` variants that travel as Payload PDUs).
pub fn register_system_payloads(reg: &SerializerRegistry) {
    use atomr_core::actor::RemoteSystemMsg;
    use std::any::TypeId;
    use std::sync::Arc;

    use super::TypeCodec;

    fn codec<T: Serialize + DeserializeOwned + Send + 'static>(id: u32) -> TypeCodec {
        TypeCodec {
            serializer_id: id,
            manifest: std::any::type_name::<T>().to_string(),
            type_id: TypeId::of::<T>(),
            encode: Arc::new(|v: &dyn std::any::Any| {
                let v = v
                    .downcast_ref::<T>()
                    .ok_or_else(|| SerializeError::Downcast(std::any::type_name::<T>().to_string()))?;
                bincode_encode(v)
            }),
            decode: Arc::new(|b: &[u8]| {
                let v: T = bincode_decode(b)?;
                Ok(Box::new(v) as Box<dyn std::any::Any + Send>)
            }),
        }
    }

    reg.register_codec(codec::<AssociateInfo>(SYSTEM_SERIALIZER_ID));
    reg.register_codec(codec::<DisassociateReason>(SYSTEM_SERIALIZER_ID));
    reg.register_codec(codec::<AckInfo>(SYSTEM_SERIALIZER_ID));
    reg.register_codec(codec::<RemoteSystemMsg>(SYSTEM_SERIALIZER_ID));

    // Register a few common user types with bincode by default so trivial
    // examples work without manual registration.
    reg.register_codec(codec::<String>(BINCODE_SERIALIZER_ID));
    reg.register_codec(codec::<Vec<u8>>(BINCODE_SERIALIZER_ID));
    reg.register_codec(codec::<i64>(BINCODE_SERIALIZER_ID));
    reg.register_codec(codec::<u64>(BINCODE_SERIALIZER_ID));
    reg.register_codec(codec::<i32>(BINCODE_SERIALIZER_ID));
    reg.register_codec(codec::<u32>(BINCODE_SERIALIZER_ID));
    reg.register_codec(codec::<bool>(BINCODE_SERIALIZER_ID));
}