wasmcloud_actor_messaging/
generated.rs

1extern crate rmp_serde as rmps;
2use rmps::{Deserializer, Serializer};
3use serde::{Deserialize, Serialize};
4use std::io::Cursor;
5
6#[cfg(feature = "guest")]
7extern crate wapc_guest as guest;
8#[cfg(feature = "guest")]
9use guest::prelude::*;
10
11#[cfg(feature = "guest")]
12pub struct Host {
13    binding: String,
14}
15
16#[cfg(feature = "guest")]
17impl Default for Host {
18    fn default() -> Self {
19        Host {
20            binding: "default".to_string(),
21        }
22    }
23}
24
25/// Creates a named host binding
26#[cfg(feature = "guest")]
27pub fn host(binding: &str) -> Host {
28    Host {
29        binding: binding.to_string(),
30    }
31}
32
33/// Creates the default host binding
34#[cfg(feature = "guest")]
35pub fn default() -> Host {
36    Host::default()
37}
38
39#[cfg(feature = "guest")]
40impl Host {
41    /// Publish a message on a given subject. If a reply is not expected, the value can
42    /// be left as an empty string.
43    pub fn publish(
44        &self,
45        subject: String,
46        reply_to: String,
47        body: Vec<u8>,
48    ) -> HandlerResult<PublishResponse> {
49        let input_args = PublishArgs {
50            subject,
51            reply_to,
52            body,
53        };
54        host_call(
55            &self.binding,
56            "wasmcloud:messaging",
57            "Publish",
58            &serialize(input_args)?,
59        )
60        .map(|vec| {
61            let resp = deserialize::<PublishResponse>(vec.as_ref()).unwrap();
62            resp
63        })
64        .map_err(|e| e.into())
65    }
66    /// Request a response on a given subject in a given timeout
67    pub fn request(
68        &self,
69        subject: String,
70        body: Vec<u8>,
71        timeout: i64,
72    ) -> HandlerResult<BrokerMessage> {
73        let input_args = RequestArgs {
74            subject,
75            body,
76            timeout,
77        };
78        host_call(
79            &self.binding,
80            "wasmcloud:messaging",
81            "Request",
82            &serialize(input_args)?,
83        )
84        .map(|vec| {
85            let resp = deserialize::<BrokerMessage>(vec.as_ref()).unwrap();
86            resp
87        })
88        .map_err(|e| e.into())
89    }
90}
91
92#[cfg(feature = "guest")]
93pub struct Handlers {}
94
95#[cfg(feature = "guest")]
96impl Handlers {
97    /// Register a function to handle an incoming message.
98    pub fn register_handle_message(f: fn(BrokerMessage) -> HandlerResult<()>) {
99        *HANDLE_MESSAGE.write().unwrap() = Some(f);
100        register_function(&"HandleMessage", handle_message_wrapper);
101    }
102}
103
104#[cfg(feature = "guest")]
105lazy_static::lazy_static! {
106static ref HANDLE_MESSAGE: std::sync::RwLock<Option<fn(BrokerMessage) -> HandlerResult<()>>> = std::sync::RwLock::new(None);
107}
108
109#[cfg(feature = "guest")]
110fn handle_message_wrapper(input_payload: &[u8]) -> CallResult {
111    let input = deserialize::<BrokerMessage>(input_payload)?;
112    let lock = HANDLE_MESSAGE.read().unwrap().unwrap();
113    let result = lock(input)?;
114    serialize(result)
115}
116
117#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
118pub struct PublishArgs {
119    #[serde(rename = "subject")]
120    pub subject: String,
121    #[serde(rename = "replyTo")]
122    pub reply_to: String,
123    #[serde(with = "serde_bytes")]
124    #[serde(rename = "body")]
125    pub body: Vec<u8>,
126}
127
128#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
129pub struct RequestArgs {
130    #[serde(rename = "subject")]
131    pub subject: String,
132    #[serde(with = "serde_bytes")]
133    #[serde(rename = "body")]
134    pub body: Vec<u8>,
135    #[serde(rename = "timeout")]
136    pub timeout: i64,
137}
138
139/// Indicates if a publish was successful
140#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
141pub struct PublishResponse {
142    #[serde(rename = "published")]
143    pub published: bool,
144}
145
146/// Incoming message object with an optionally empty reply field
147#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
148pub struct BrokerMessage {
149    #[serde(rename = "subject")]
150    pub subject: String,
151    #[serde(rename = "replyTo")]
152    pub reply_to: String,
153    #[serde(with = "serde_bytes")]
154    #[serde(rename = "body")]
155    pub body: Vec<u8>,
156}
157
158/// The standard function for serializing codec structs into a format that can be
159/// used for message exchange between actor and host. Use of any other function to
160/// serialize could result in breaking incompatibilities.
161pub fn serialize<T>(
162    item: T,
163) -> ::std::result::Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>>
164where
165    T: Serialize,
166{
167    let mut buf = Vec::new();
168    item.serialize(&mut Serializer::new(&mut buf).with_struct_map())?;
169    Ok(buf)
170}
171
172/// The standard function for de-serializing codec structs from a format suitable
173/// for message exchange between actor and host. Use of any other function to
174/// deserialize could result in breaking incompatibilities.
175pub fn deserialize<'de, T: Deserialize<'de>>(
176    buf: &[u8],
177) -> ::std::result::Result<T, Box<dyn std::error::Error + Send + Sync>> {
178    let mut de = Deserializer::new(Cursor::new(buf));
179    match Deserialize::deserialize(&mut de) {
180        Ok(t) => Ok(t),
181        Err(e) => Err(format!("Failed to de-serialize: {}", e).into()),
182    }
183}
wasmcloud_actor_messaging/generated.rs

wasmcloud_actor_messaging/
generated.rs
