casper-binary-port 1.1.1

Types for the casper node binary port
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use casper_types::bytesrepr::{self, Bytes, FromBytes, ToBytes};

use crate::{binary_response::BinaryResponse, response_type::PayloadEntity, ResponseType};

use crate::record_id::RecordId;
#[cfg(test)]
use casper_types::testing::TestRng;

/// The binary response along with the original binary request attached.
#[derive(Debug, PartialEq)]
pub struct BinaryResponseAndRequest {
    /// Context of the original request.
    request: Bytes,
    /// The response.
    response: BinaryResponse,
}

impl BinaryResponseAndRequest {
    /// Creates new binary response with the original request attached.
    pub fn new(data: BinaryResponse, request: Bytes) -> Self {
        Self {
            request,
            response: data,
        }
    }

    /// Returns a new binary response with specified data and no original request.
    pub fn new_test_response<A: PayloadEntity + ToBytes>(
        record_id: RecordId,
        data: &A,
    ) -> BinaryResponseAndRequest {
        let response = BinaryResponse::from_raw_bytes(
            ResponseType::from_record_id(record_id, false),
            data.to_bytes().unwrap(),
        );
        Self::new(response, Bytes::from(vec![]))
    }

    /// Returns a new binary response with specified legacy data and no original request.
    pub fn new_legacy_test_response<A: PayloadEntity + serde::Serialize>(
        record_id: RecordId,
        data: &A,
    ) -> BinaryResponseAndRequest {
        let response = BinaryResponse::from_raw_bytes(
            ResponseType::from_record_id(record_id, true),
            bincode::serialize(data).unwrap(),
        );
        Self::new(response, Bytes::from(vec![]))
    }

    /// Returns true if response is success.
    pub fn is_success(&self) -> bool {
        self.response.is_success()
    }

    /// Returns the error code.
    pub fn error_code(&self) -> u16 {
        self.response.error_code()
    }

    #[cfg(test)]
    pub(crate) fn random(rng: &mut TestRng) -> Self {
        let bytes = vec![1; 155];
        Self {
            request: Bytes::from(bytes),
            response: BinaryResponse::random(rng),
        }
    }

    /// Returns serialized bytes representing the original request.
    pub fn request(&self) -> &[u8] {
        &self.request
    }

    /// Returns the inner binary response.
    pub fn response(&self) -> &BinaryResponse {
        &self.response
    }
}

impl ToBytes for BinaryResponseAndRequest {
    fn to_bytes(&self) -> Result<Vec<u8>, bytesrepr::Error> {
        let mut buffer = bytesrepr::allocate_buffer(self)?;
        self.write_bytes(&mut buffer)?;
        Ok(buffer)
    }

    fn write_bytes(&self, writer: &mut Vec<u8>) -> Result<(), bytesrepr::Error> {
        let BinaryResponseAndRequest { request, response } = self;
        request.write_bytes(writer)?;
        response.write_bytes(writer)
    }

    fn serialized_length(&self) -> usize {
        self.request.serialized_length() + self.response.serialized_length()
    }
}

impl FromBytes for BinaryResponseAndRequest {
    fn from_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), bytesrepr::Error> {
        let (request, remainder) = FromBytes::from_bytes(bytes)?;
        let (response, remainder) = FromBytes::from_bytes(remainder)?;

        Ok((BinaryResponseAndRequest { request, response }, remainder))
    }
}

impl From<BinaryResponseAndRequest> for BinaryResponse {
    fn from(response_and_request: BinaryResponseAndRequest) -> Self {
        let BinaryResponseAndRequest { response, .. } = response_and_request;
        response
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use casper_types::testing::TestRng;

    #[test]
    fn roundtrip() {
        let rng = &mut TestRng::new();
        let bytes = vec![1; 155];
        let response = BinaryResponse::random(rng);
        let val = BinaryResponseAndRequest::new(response, Bytes::from(bytes));
        bytesrepr::test_serialization_roundtrip(&val);
    }

    #[test]
    fn bytesrepr_roundtrip() {
        let rng = &mut TestRng::new();

        let val = BinaryResponseAndRequest::random(rng);
        bytesrepr::test_serialization_roundtrip(&val);
    }
}