shors 0.12.6

Transport layer for cartridge + tarantool-module projects.
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

use crate::tarantool::error::Error;
use crate::tarantool::tuple::Tuple;
use rmpv::Value;
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::io;

pub mod client;
pub mod route;
pub mod server;

/// Rpc request.
#[derive(Debug)]
pub struct Request {
    tup: Tuple,
}

impl Request {
    /// Parse rpc request into some type.
    #[allow(clippy::result_large_err)]
    pub fn parse<T: DeserializeOwned>(self) -> Result<T, Error> {
        fn invalid_format_err() -> Error {
            Error::IO(io::Error::other("invalid tuple format"))
        }

        let arguments = self
            .tup
            .try_get::<_, rmpv::Value>(2)?
            .ok_or_else(invalid_format_err)?;

        match arguments {
            Value::String(raw_mp_argument) => {
                Ok(rmp_serde::from_slice(raw_mp_argument.as_bytes())?)
            }
            Value::Binary(raw_mp_argument) => Ok(rmp_serde::from_slice(&raw_mp_argument)?),
            _ => Err(invalid_format_err()),
        }
    }
}

/// Rpc response.
#[derive(Debug)]
pub struct Response {
    bytes: Vec<u8>,
}

impl Response {
    pub fn new<T: Serialize>(serializable: T) -> Response {
        Response {
            bytes: rmp_serde::to_vec_named(&serializable).unwrap(),
        }
    }
}

impl<T: Serialize> From<T> for Response {
    fn from(serializable: T) -> Self {
        Response::new(serializable)
    }
}