rpc_pb 0.15.0

rpc_pb provides prototk definitions for an RPC layer.
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

use std::ops::Deref;
use std::sync::Mutex;

use prototk_derive::Message;

use rpc_pb::{Context, service};

mod common;

use common::Error;

//////////////////////////////////////////// The Service ///////////////////////////////////////////

#[derive(Debug, Default, Message)]
pub struct CacheLoad<'a> {
    #[prototk(1, bytes)]
    key: &'a [u8],
}

#[derive(Debug, Default, Message)]
pub struct CacheResponse {
    #[prototk(2, bytes)]
    val: Option<Vec<u8>>,
}

#[derive(Debug, Default, Message)]
pub struct CacheStore<'a> {
    #[prototk(1, bytes)]
    key: &'a [u8],
    #[prototk(2, bytes)]
    val: &'a [u8],
}

#[derive(Debug, Default, Message)]
pub struct CacheEmpty {}

service! {
    name = Cache; // No magic.  The name of the trait for this service.
    server = CacheServer; // No magic.  The name of the type for the server.
    client = CacheClient; // No magic.  The name of the type for the client.
    error = Error; // No magic.  The name of the error type.  Must implement From<rpc_pb::Error>.
    rpc load(CacheLoad) -> CacheResponse;
    rpc store(CacheStore) -> CacheEmpty;
}

////////////////////////////////////////// Implementation //////////////////////////////////////////

pub struct CachedRegister {
    value: Mutex<(Vec<u8>, Vec<u8>)>,
}

impl Cache for CachedRegister {
    fn load(&self, _: &Context, req: CacheLoad) -> Result<CacheResponse, Error> {
        let guard = self.value.lock().unwrap();
        let (key, value) = guard.deref();
        if key == req.key {
            let val = Some(value.clone());
            Ok(CacheResponse { val })
        } else {
            Ok(CacheResponse { val: None })
        }
    }

    fn store(&self, _: &Context, req: CacheStore) -> Result<CacheEmpty, Error> {
        let key = req.key.to_vec();
        let val = req.val.to_vec();
        *self.value.lock().unwrap() = (key, val);
        Ok(CacheEmpty {})
    }
}

fn main() {}