dyniak 1.4.1

Riak-compatible protocol surface (HTTP + PBC) and storage bridge for the Dynomite Rust port
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Wire-codec wiring for the Riak PBC operation surface.
//!
//! A single [`dyn_encoding::ProtobufCodec`] is built once and stocked
//! with every message type the PBC surface exchanges on the wire.
//! The codec is then installed into a [`dyn_encoding::CodecRegistry`]
//! under the canonical Riak content-type
//! `"application/x-protobuf"`. Higher layers ask the registry for
//! `"application/x-protobuf"` to encode and decode bodies. The HTTP
//! gateway maintains its own registry
//! ([`crate::proto::http::object::object_codecs`]) carrying JSON,
//! CBOR, and protobuf codecs under their respective content-types.

use dyn_encoding::{CodecRegistry, ProtobufCodec};

use crate::proto::pb::messages::{
    RpbDelReq, RpbErrorResp, RpbGetBucketReq, RpbGetBucketResp, RpbGetReq, RpbGetResp,
    RpbGetServerInfoResp, RpbIndexReq, RpbIndexResp, RpbListBucketsReq, RpbListBucketsResp,
    RpbListKeysReq, RpbListKeysResp, RpbPingReq, RpbPingResp, RpbPutReq, RpbPutResp,
    RpbServerInfoReq, RpbSetBucketReq, RpbSetBucketResp,
};

/// Content-type the Riak PBC transport uses unconditionally.
pub const PBC_CONTENT_TYPE: &str = "application/x-protobuf";

/// Registry returned by [`codec_registry`].
///
/// Carries the [`CodecRegistry`] plus the list of registered
/// content-types so callers can introspect the bundle without
/// re-walking the registry.
pub struct PbCodecBundle {
    /// The codec registry holding the protobuf codec.
    pub registry: CodecRegistry,
}

impl PbCodecBundle {
    /// Borrow the configured codec registry.
    #[must_use]
    pub fn registry(&self) -> &CodecRegistry {
        &self.registry
    }
}

/// Build a codec registry with a [`ProtobufCodec`] populated for
/// every message type the Riak PBC transport touches in v0.0.1.
///
/// # Examples
///
/// ```
/// use dyniak::proto::pb::{codec_registry, PBC_CONTENT_TYPE};
/// let bundle = codec_registry();
/// assert!(bundle.registry().for_content_type(PBC_CONTENT_TYPE).is_some());
/// ```
#[must_use]
pub fn codec_registry() -> PbCodecBundle {
    let mut codec = ProtobufCodec::new();
    codec
        .register::<RpbErrorResp>()
        .register::<RpbPingReq>()
        .register::<RpbPingResp>()
        .register::<RpbGetReq>()
        .register::<RpbGetResp>()
        .register::<RpbPutReq>()
        .register::<RpbPutResp>()
        .register::<RpbDelReq>()
        .register::<RpbServerInfoReq>()
        .register::<RpbGetServerInfoResp>()
        .register::<RpbListBucketsReq>()
        .register::<RpbListBucketsResp>()
        .register::<RpbListKeysReq>()
        .register::<RpbListKeysResp>()
        .register::<RpbGetBucketReq>()
        .register::<RpbGetBucketResp>()
        .register::<RpbSetBucketReq>()
        .register::<RpbSetBucketResp>()
        .register::<RpbIndexReq>()
        .register::<RpbIndexResp>();

    let mut registry = CodecRegistry::new();
    registry.register(codec);
    PbCodecBundle { registry }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::proto::pb::messages::RpbGetReq;
    use dyn_encoding::WireValue;

    #[test]
    fn registry_has_protobuf_codec() {
        let bundle = codec_registry();
        let codec = bundle
            .registry()
            .for_content_type(PBC_CONTENT_TYPE)
            .expect("protobuf codec installed");
        assert_eq!(codec.content_type(), PBC_CONTENT_TYPE);
    }

    #[test]
    fn registry_round_trips_get_request() {
        let bundle = codec_registry();
        let codec = bundle
            .registry()
            .for_content_type(PBC_CONTENT_TYPE)
            .expect("codec");
        let req = RpbGetReq {
            bucket: b"b".to_vec(),
            key: b"k".to_vec(),
            ..RpbGetReq::default()
        };
        let bytes = codec.encode(&req).expect("encode");
        let back = codec
            .decode(RpbGetReq::wire_type_id(), &bytes)
            .expect("decode");
        let back = back.as_any().downcast_ref::<RpbGetReq>().expect("downcast");
        assert_eq!(back, &req);
    }
}