remoc 0.18.3

🦑 Remote multiplexed objects, channels, observable collections and RPC making remote interactions seamless. Provides multiple remote channels and RPC over TCP, TLS or any other transport.
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

#[cfg(feature = "js")]
use wasm_bindgen_test::wasm_bindgen_test;

use crate::loop_channel;

// Avoid imports here to test if proc macro works without imports.

#[remoc::rtc::remote]
pub trait DataGenerator {
    async fn data(&self, size: usize) -> Result<Vec<u8>, remoc::rtc::CallError>;
}

pub struct DataGeneratorObj {}

impl DataGeneratorObj {
    pub fn new() -> Self {
        Self {}
    }
}

impl DataGenerator for DataGeneratorObj {
    async fn data(&self, size: usize) -> Result<Vec<u8>, remoc::rtc::CallError> {
        Ok(vec![1; size])
    }
}

#[cfg_attr(not(feature = "js"), tokio::test)]
#[cfg_attr(feature = "js", wasm_bindgen_test)]
async fn max_item_size_exceeded() {
    use remoc::rtc::{Client, ServerRefMut};

    crate::init();
    let ((mut a_tx, _), (_, mut b_rx)) = loop_channel::<DataGeneratorClient>().await;

    let mut gen_obj = DataGeneratorObj::new();
    let (server, client) = DataGeneratorServerRefMut::new(&mut gen_obj, 1);

    a_tx.send(client).await.unwrap();

    let client_task = async move {
        println!("Receiving client");
        let mut client = b_rx.recv().await.unwrap().unwrap();

        client.set_max_reply_size(16777);
        let max_item_size = client.max_reply_size();

        let elems = max_item_size / 10;
        println!("Getting {elems} elements, which is under limit");
        let rxed = client.data(elems).await.unwrap();
        println!("Received {} elements", rxed.len());
        assert_eq!(rxed.len(), elems);

        let elems = max_item_size * 10;
        println!("Getting {elems} elements, which is over limit");
        let rxed = client.data(elems).await;
        assert!(matches!(rxed, Err(remoc::rtc::CallError::Dropped)));
    };

    let ((), res) = tokio::join!(client_task, server.serve());
    assert!(matches!(
        res,
        Err(remoc::rtc::ServeError::ReplySend(remoc::rch::SendingErrorKind::Send(
            remoc::rch::base::SendErrorKind::MaxItemSizeExceeded
        )))
    ));
}