cloudburst 0.0.5

A library to help with the implementation of torrent based protocols and algorithms.
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// Copyright 2022 Bryant Luk
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! Serialization of KRPC messages.

use serde::{ser::SerializeMap, Serialize, Serializer};

struct AsBytes<'a>(&'a [u8]);

impl<'a> Serialize for AsBytes<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self.0)
    }
}

/// Query message.
#[derive(Debug)]
pub struct QueryMsg<'a, T> {
    /// Query arguments
    pub a: T,
    /// Method name of query
    pub q: &'a [u8],
    /// Transaction id
    pub t: &'a [u8],
    /// Client version
    pub v: Option<&'a [u8]>,
}

impl<'a, T> Serialize for QueryMsg<'a, T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(None)?;
        map.serialize_entry("a", &self.a)?;
        map.serialize_entry("q", &AsBytes(self.q))?;
        map.serialize_entry("t", &AsBytes(self.t))?;
        if let Some(v) = &self.v {
            map.serialize_entry("v", &AsBytes(v))?;
        }
        map.serialize_entry("y", "q")?;
        map.end()
    }
}

/// Response message.
#[derive(Debug)]
pub struct RespMsg<'a, T> {
    /// Return values
    pub r: T,
    /// Transaction id
    pub t: &'a [u8],
    /// Client version
    pub v: Option<&'a [u8]>,
}

impl<'a, T> Serialize for RespMsg<'a, T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(None)?;
        map.serialize_entry("r", &self.r)?;
        map.serialize_entry("t", &AsBytes(self.t))?;
        if let Some(v) = self.v {
            map.serialize_entry("v", &AsBytes(v))?;
        }
        map.serialize_entry("y", "r")?;
        map.end()
    }
}

/// Error message.
#[derive(Debug)]
pub struct ErrMsg<'a, T> {
    /// Error details
    pub e: T,
    /// Transaction id
    pub t: &'a [u8],
    /// Client version
    pub v: Option<&'a [u8]>,
}

impl<'a, T> Serialize for ErrMsg<'a, T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(None)?;
        map.serialize_entry("e", &self.e)?;
        map.serialize_entry("t", &AsBytes(self.t))?;
        if let Some(v) = self.v {
            map.serialize_entry("v", &AsBytes(v))?;
        }
        map.serialize_entry("y", "e")?;
        map.end()
    }
}

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

    use crate::dht::krpc::{Error, ErrorCode, Msg, Ty};

    #[test]
    fn test_serde_error() -> Result<(), Error> {
        let encoded_error = b"d1:eli201e23:A Generic Error Ocurrede1:t2:aa1:y1:ee";

        let error_msg: Msg<'_> = bt_bencode::from_slice(encoded_error)?;
        assert_eq!(error_msg.ty(), Ty::Error);
        assert_eq!(error_msg.tx_id(), b"aa".as_ref());
        assert_eq!(
            error_msg.error(),
            Some((ErrorCode::GenericError, "A Generic Error Ocurred"))
        );

        let ser_error_msg = ErrMsg {
            e: &(201, "A Generic Error Ocurred"),
            t: b"aa",
            v: None,
        };
        let ser_msg = bt_bencode::to_vec(&ser_error_msg).unwrap();
        assert_eq!(ser_msg, encoded_error);
        Ok(())
    }
}