wamp_async 0.3.1

An asynchronous WAMP implementation
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

use std::error::Error;

use serde::{Deserialize, Serialize};

use wamp_async::{
    try_into_any_value, Client, ClientConfig, ClientRole, SerializerType, WampKwArgs,
};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct MyStruct {
    field1: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    env_logger::init();

    // Connect to the server
    let (mut client, (evt_loop, _rpc_evt_queue)) = Client::connect(
        "wss://localhost:8080/ws",
        Some(
            ClientConfig::default()
                .set_ssl_verify(false)
                // Restrict our roles
                .set_roles(vec![ClientRole::Caller])
                // Only use Json serialization
                .set_serializers(vec![SerializerType::Json]),
        ),
    )
    .await?;
    println!("Connected !!");

    // Spawn the event loop
    tokio::spawn(evt_loop);

    println!("Joining realm");
    client.join_realm("realm1").await?;

    let my_struct = MyStruct {
        field1: "value1".to_string(),
    };
    let positional_args = vec![
        12i64.into(),
        13.3f64.into(),
        u32::MAX.into(),
        i32::MIN.into(),
        u64::MAX.into(),
        "str".into(),
        vec![-1].into(),
        try_into_any_value(&my_struct).unwrap(),
    ];
    let mut keyword_args = WampKwArgs::new();
    keyword_args.insert("key".to_string(), try_into_any_value(&my_struct).unwrap());

    for (send_args, send_kwargs) in vec![
        (None, None),
        (Some(positional_args.clone()), None),
        (None, Some(keyword_args.clone())),
        (Some(positional_args.clone()), Some(keyword_args.clone())),
    ] {
        let send_args_copy = send_args.clone();
        let send_kwargs_copy = send_kwargs.clone();

        // Call the RPC endpoint and wait for the result
        println!(
            "Calling 'peer.echo' with {:?} and {:?}",
            send_args, send_kwargs
        );
        match client.call("peer.echo", send_args, send_kwargs).await {
            Ok((res_args, res_kwargs)) => {
                println!("\tGot {:?} {:?}", res_args, res_kwargs);
                assert_eq!(res_args, send_args_copy);
                assert_eq!(res_kwargs, send_kwargs_copy);
            }
            Err(e) => {
                println!("Error calling ({:?})", e);
                break;
            }
        };

        println!();
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }

    println!("Leaving realm");
    client.leave_realm().await?;

    client.disconnect().await;
    Ok(())
}