coreemu/
client.rs

1use futures_util::stream;
2use tonic::transport::Channel;
3use tonic::Request;
4use tonic::Streaming;
5
6use crate::core::core_api_client::CoreApiClient;
7use crate::core::*;
8use crate::mobility::*;
9
10pub struct Client {
11    inner: CoreApiClient<Channel>,
12}
13
14impl Client {
15    pub async fn connect(core_addr: String) -> Result<Self, tonic::transport::Error> {
16        Ok(Client {
17            inner: CoreApiClient::connect(core_addr).await?,
18        })
19    }
20
21    pub fn inner(&mut self) -> &mut CoreApiClient<Channel> {
22        &mut self.inner
23    }
24
25    pub async fn get_sessions(
26        &mut self,
27    ) -> Result<Vec<crate::core::SessionSummary>, tonic::Status> {
28        let request = tonic::Request::new(GetSessionsRequest {});
29
30        Ok(self
31            .inner()
32            .get_sessions(request)
33            .await?
34            .into_inner()
35            .sessions)
36    }
37
38    pub async fn get_session(
39        &mut self,
40        session_id: i32,
41    ) -> Result<Option<crate::core::Session>, tonic::Status> {
42        let request = tonic::Request::new(GetSessionRequest { session_id });
43        Ok(self
44            .inner()
45            .get_session(request)
46            .await?
47            .into_inner()
48            .session)
49    }
50
51    pub async fn get_node(
52        &mut self,
53        session_id: i32,
54        node_id: i32,
55    ) -> Result<crate::core::GetNodeResponse, tonic::Status> {
56        let request = tonic::Request::new(GetNodeRequest {
57            session_id,
58            node_id,
59        });
60        Ok(self.inner().get_node(request).await?.into_inner())
61    }
62    pub async fn edit_node(
63        &mut self,
64        session_id: i32,
65        node_id: i32,
66        position: Option<crate::core::Position>,
67        icon: String,
68        source: String,
69        geo: Option<crate::core::Geo>,
70    ) -> Result<crate::core::EditNodeResponse, tonic::Status> {
71        let request = tonic::Request::new(EditNodeRequest {
72            session_id,
73            node_id,
74            position,
75            icon,
76            source,
77            geo,
78        });
79        Ok(self.inner().edit_node(request).await?.into_inner())
80    }
81    pub async fn create_session(
82        &mut self,
83        session_id: i32,
84    ) -> Result<crate::core::CreateSessionResponse, tonic::Status> {
85        let request = tonic::Request::new(CreateSessionRequest { session_id });
86        Ok(self.inner().create_session(request).await?.into_inner())
87    }
88    pub async fn stop_session(
89        &mut self,
90        session_id: i32,
91    ) -> Result<crate::core::StopSessionResponse, tonic::Status> {
92        let request = tonic::Request::new(StopSessionRequest { session_id });
93        Ok(self.inner().stop_session(request).await?.into_inner())
94    }
95    pub async fn open_xml(
96        &mut self,
97        data: String,
98        start: bool,
99        file: String,
100    ) -> Result<crate::core::OpenXmlResponse, tonic::Status> {
101        let request = tonic::Request::new(OpenXmlRequest { data, start, file });
102        Ok(self.inner().open_xml(request).await?.into_inner())
103    }
104    pub async fn save_xml(
105        &mut self,
106        session_id: i32,
107    ) -> Result<crate::core::SaveXmlResponse, tonic::Status> {
108        let request = tonic::Request::new(SaveXmlRequest { session_id });
109        Ok(self.inner().save_xml(request).await?.into_inner())
110    }
111
112    pub async fn execute_script(
113        &mut self,
114        script: String,
115    ) -> Result<crate::core::ExecuteScriptResponse, tonic::Status> {
116        let request = tonic::Request::new(ExecuteScriptRequest { script });
117        Ok(self.inner().execute_script(request).await?.into_inner())
118    }
119
120    pub async fn node_command(
121        &mut self,
122        session_id: i32,
123        node_id: i32,
124        command: String,
125        wait: bool,
126        shell: bool,
127    ) -> Result<crate::core::NodeCommandResponse, tonic::Status> {
128        let request = tonic::Request::new(NodeCommandRequest {
129            session_id,
130            node_id,
131            command,
132            wait,
133            shell,
134        });
135        Ok(self.inner().node_command(request).await?.into_inner())
136    }
137    pub async fn move_nodes(
138        &mut self,
139        moves: Vec<MoveNodesRequest>,
140    ) -> Result<crate::core::MoveNodesResponse, tonic::Status> {
141        /*let request = Request::new(MoveNodesRequest {
142            session_id,
143            node_id,
144            source,
145            move_type,
146        });*/
147        Ok(self
148            .inner()
149            .move_nodes(stream::iter(moves))
150            .await?
151            .into_inner())
152    }
153    pub async fn mobility_action(
154        &mut self,
155        session_id: i32,
156        node_id: i32,
157        action: crate::mobility::mobility_action::Enum,
158    ) -> Result<MobilityActionResponse, tonic::Status> {
159        let request = Request::new(MobilityActionRequest {
160            session_id,
161            node_id,
162            action: action as i32,
163        });
164        Ok(self.inner().mobility_action(request).await?.into_inner())
165    }
166
167    pub async fn events(
168        &mut self,
169        session_id: i32,
170        events: Vec<event_type::Enum>,
171    ) -> Result<Streaming<Event>, tonic::Status> {
172        let request = tonic::Request::new(EventsRequest {
173            session_id,
174            events: events.iter().map(|e| *e as i32).collect(),
175        });
176        Ok(self.inner().events(request).await?.into_inner())
177    }
178}
coreemu/client.rs

coreemu/
client.rs
