taubyte_sdk/pubsub/event/
channel.rs

1use super::{imports, Event};
2use crate::{errno::Error, pubsub::node::Channel};
3
4impl Event {
5    fn channel_size_unsafe(&self, size: *mut usize) -> Error {
6        #[allow(unused_unsafe)]
7        unsafe {
8            imports::getMessageChannelSize(self.event, size)
9        }
10    }
11
12    fn channel_unsafe(&self, buf_ptr: *mut u8) -> Error {
13        #[allow(unused_unsafe)]
14        unsafe {
15            imports::getMessageChannel(self.event, buf_ptr)
16        }
17    }
18
19    pub fn channel(&self) -> Result<Channel, Box<dyn std::error::Error>> {
20        let mut size: usize = 0;
21        let err0 = self.channel_size_unsafe(&mut size);
22        if err0.is_err() {
23            return Err(format!(
24                "Getting channel size for event: `{}` failed with: {}",
25                self.event, err0
26            )
27            .into());
28        }
29        if size == 0 {
30            return Ok(Channel::new("".to_string())?);
31        }
32
33        let mut buf = vec![0u8; size];
34        let err0 = self.channel_unsafe(buf.as_mut_ptr());
35        if err0.is_err() {
36            Err(format!(
37                "Getting channel for event: `{}` failed with: {}",
38                self.event, err0
39            )
40            .into())
41        } else {
42            Ok(Channel::new(String::from_utf8(buf)?)?)
43        }
44    }
45}
46
47#[cfg(test)]
48pub mod test {
49    use crate::pubsub::Event;
50    pub static ID: u32 = 3;
51    pub static CHANNEL: &str = "testChannel";
52
53    #[test]
54    fn event_channel() {
55        let event = Event { event: ID };
56        let channel = event.channel().unwrap();
57        assert_eq!(channel.name(), CHANNEL);
58    }
59}
60
61#[cfg(test)]
62#[allow(non_snake_case)]
63pub mod mock {
64    use super::test;
65    use crate::{
66        errno::{Errno, Error},
67        utils::test as utils,
68    };
69
70    pub fn getMessageChannelSize(event: u32, size: *mut usize) -> Error {
71        if event != test::ID {
72            Errno::ErrorCap.error()
73        } else {
74            utils::write_usize(size, test::CHANNEL.len());
75            Errno::ErrorNone.error()
76        }
77    }
78
79    pub fn getMessageChannel(event: u32, buf_ptr: *mut u8) -> Error {
80        if event != test::ID {
81            Errno::ErrorCap.error()
82        } else {
83            utils::write_string(buf_ptr, test::CHANNEL);
84            Errno::ErrorNone.error()
85        }
86    }
87}