wasmcloud_actor_eventstreams/
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    /// Write an event to the given stream ID
42    pub fn write_event(
43        &self,
44        stream_id: String,
45        values: std::collections::HashMap<String, String>,
46    ) -> HandlerResult<EventAck> {
47        let input_args = WriteEventArgs { stream_id, values };
48        host_call(
49            &self.binding,
50            "wasmcloud:eventstreams",
51            "WriteEvent",
52            &serialize(input_args)?,
53        )
54        .map(|vec| {
55            let resp = deserialize::<EventAck>(vec.as_ref()).unwrap();
56            resp
57        })
58        .map_err(|e| e.into())
59    }
60    /// Query a stream for the list of events
61    pub fn query_stream(&self, query: StreamQuery) -> HandlerResult<EventList> {
62        host_call(
63            &self.binding,
64            "wasmcloud:eventstreams",
65            "QueryStream",
66            &serialize(query)?,
67        )
68        .map(|vec| {
69            let resp = deserialize::<EventList>(vec.as_ref()).unwrap();
70            resp
71        })
72        .map_err(|e| e.into())
73    }
74}
75
76#[cfg(feature = "guest")]
77pub struct Handlers {}
78
79#[cfg(feature = "guest")]
80impl Handlers {
81    /// Handle an incoming event
82    pub fn register_deliver_event(f: fn(Event) -> HandlerResult<EventAck>) {
83        *DELIVER_EVENT.write().unwrap() = Some(f);
84        register_function(&"DeliverEvent", deliver_event_wrapper);
85    }
86}
87
88#[cfg(feature = "guest")]
89lazy_static::lazy_static! {
90static ref DELIVER_EVENT: std::sync::RwLock<Option<fn(Event) -> HandlerResult<EventAck>>> = std::sync::RwLock::new(None);
91}
92
93#[cfg(feature = "guest")]
94fn deliver_event_wrapper(input_payload: &[u8]) -> CallResult {
95    let input = deserialize::<Event>(input_payload)?;
96    let lock = DELIVER_EVENT.read().unwrap().unwrap();
97    let result = lock(input)?;
98    Ok(serialize(result)?)
99}
100
101#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
102pub struct WriteEventArgs {
103    #[serde(rename = "streamId")]
104    pub stream_id: String,
105    #[serde(rename = "values")]
106    pub values: std::collections::HashMap<String, String>,
107}
108
109/// A single event that occurred on a given stream
110#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
111pub struct Event {
112    #[serde(rename = "eventId")]
113    pub event_id: String,
114    #[serde(rename = "streamId")]
115    pub stream_id: String,
116    #[serde(rename = "values")]
117    pub values: std::collections::HashMap<String, String>,
118}
119
120/// Result object used for error handling and acknowledgement of events
121#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
122pub struct EventAck {
123    #[serde(rename = "eventId")]
124    pub event_id: Option<String>,
125    #[serde(rename = "error")]
126    pub error: Option<String>,
127}
128
129/// Wrapper object around a list of events
130#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
131pub struct EventList {
132    #[serde(rename = "events")]
133    pub events: Vec<Event>,
134}
135
136/// Used to query a stream for events with a maximum event count and optional time
137/// frame
138#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
139pub struct StreamQuery {
140    #[serde(rename = "streamId")]
141    pub stream_id: String,
142    #[serde(rename = "range")]
143    pub range: Option<TimeRange>,
144    #[serde(rename = "count")]
145    pub count: u64,
146}
147
148/// Defines a range of time with a minimum and maximum timestamp (epoch time)
149#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
150pub struct TimeRange {
151    #[serde(rename = "minTime")]
152    pub min_time: u64,
153    #[serde(rename = "maxTime")]
154    pub max_time: u64,
155}
156
157/// The standard function for serializing codec structs into a format that can be
158/// used for message exchange between actor and host. Use of any other function to
159/// serialize could result in breaking incompatibilities.
160pub fn serialize<T>(
161    item: T,
162) -> ::std::result::Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>>
163where
164    T: Serialize,
165{
166    let mut buf = Vec::new();
167    item.serialize(&mut Serializer::new(&mut buf).with_struct_map())?;
168    Ok(buf)
169}
170
171/// The standard function for de-serializing codec structs from a format suitable
172/// for message exchange between actor and host. Use of any other function to
173/// deserialize could result in breaking incompatibilities.
174pub fn deserialize<'de, T: Deserialize<'de>>(
175    buf: &[u8],
176) -> ::std::result::Result<T, Box<dyn std::error::Error + Send + Sync>> {
177    let mut de = Deserializer::new(Cursor::new(buf));
178    match Deserialize::deserialize(&mut de) {
179        Ok(t) => Ok(t),
180        Err(e) => Err(format!("Failed to de-serialize: {}", e).into()),
181    }
182}
wasmcloud_actor_eventstreams/generated.rs

wasmcloud_actor_eventstreams/
generated.rs
