openwhisk_client_rust/api/
trigger.rs

1use super::NAMESPACE_ENDPOINT;
2use super::{HttpMethods, Limits, Service, TRIGGERS_ENDPOINT};
3use crate::client::Context;
4use derive_new::new;
5use serde::{Deserialize, Serialize};
6use serde_json::Value;
7
8/// Representation of Trigger Service
9#[derive(new, Default, Debug, Clone)]
10pub struct TriggerService<T> {
11    /// A trigger service must have a client to handle http request
12    client: T,
13    /// A trigger service uses the context which sets openwhisk properties
14    context: Context,
15}
16
17/// Represenation of Trigger
18#[derive(Debug, Deserialize, Serialize, Clone, Default)]
19pub struct Trigger {
20    /// The namespace name
21    #[serde(default)]
22    pub namespace: String,
23    /// The trigger name
24    #[serde(default)]
25    pub name: String,
26    /// Version
27    pub version: String,
28    /// Publish to true or flase
29    #[serde(default)]
30    pub publish: bool,
31    /// Number of times the trigger has been updated
32    #[serde(default)]
33    pub updated: i64,
34    /// Annotations used
35    pub annotations: Vec<KeyValue>,
36    /// Parameters required
37    #[serde(default)]
38    pub parameters: Vec<KeyValue>,
39    /// Trigger rate Limits  
40    #[serde(default)]
41    #[serde(skip_serializing)]
42    pub limits: Limits,
43}
44
45#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
46pub struct KeyValue {
47    pub key: String,
48    pub value: Value,
49}
50#[derive(Debug, Deserialize, Serialize, Clone)]
51pub struct TriggerListOptions {
52    /// The limit for the trigger
53    pub limit: i64,
54    /// Skip count
55    pub skip: i64,
56    /// And the document is required or not should be passed as parameters
57    pub docs: bool,
58}
59
60impl<T> TriggerService<T>
61where
62    T: Service,
63{
64    /// Returns a list of Triggers
65    pub fn list(&self) -> Result<Vec<Trigger>, String> {
66        let url = format!(
67            "{}/api/v1/{}/{}/{}",
68            self.context.host(),
69            NAMESPACE_ENDPOINT,
70            self.context.namespace(),
71            TRIGGERS_ENDPOINT
72        );
73
74        let user_auth = self.context.auth();
75        let user = user_auth.0;
76        let pass = user_auth.1;
77
78        let request = match self.client.new_request(
79            Some(HttpMethods::GET),
80            url.as_str(),
81            Some((user, pass)),
82            None,
83        ) {
84            Ok(request) => request,
85            Err(error) => return Err(error),
86        };
87
88        match self.client.invoke_request(request) {
89            Ok(value) => match serde_json::from_value(value) {
90                Ok(result) => Ok(result),
91                Err(error) => Err(format!("Failed deserailize triggers {}", error)),
92            },
93
94            Err(error) => Err(format!("Failed to fetch the list of triggers {}", error)),
95        }
96    }
97
98    /// Inserts a trigger
99    ///
100    /// # Arguments
101    /// * `trigger` - The trigger ro be inserted
102    /// * `overwrite`  - Toggle to get overwrtite an existing trigger
103    ///
104    pub fn insert(&self, trigger: &Trigger, overwrite: bool) -> Result<Trigger, String> {
105        let url = format!(
106            "{}/api/v1/{}/{}/{}/{}?overwrite={}",
107            self.context.host(),
108            NAMESPACE_ENDPOINT,
109            self.context.namespace(),
110            TRIGGERS_ENDPOINT,
111            trigger.name,
112            overwrite,
113        );
114
115        let user_auth = self.context.auth();
116        let user = user_auth.0;
117        let pass = user_auth.1;
118
119        let body = match serde_json::to_value(trigger) {
120            Ok(value) => value,
121            Err(err) => return Err(format!("failed to serialize body {}", err)),
122        };
123
124        let request = match self.client.new_request(
125            Some(HttpMethods::PUT),
126            url.as_str(),
127            Some((user, pass)),
128            Some(body),
129        ) {
130            Ok(request) => request,
131            Err(err) => return Err(format!("failed to create request {}", err)),
132        };
133
134        let trigger: Trigger = match self.client.invoke_request(request) {
135            Ok(response) => match serde_json::from_value(response) {
136                Ok(trigger) => trigger,
137                Err(err) => return Err(format!("falied to deserilaize {}", err)),
138            },
139            Err(err) => return Err(format!("falied to insert trigger {}", err)),
140        };
141
142        Ok(trigger)
143    }
144
145    /// To get the properties of the trigger
146    ///
147    /// # Arguments
148    /// * `trigger_name` - String slice that holds trigger name
149    ///
150    pub fn get(&self, trigger_name: &str) -> Result<Trigger, String> {
151        let url = format!(
152            "{}/api/v1/{}/{}/{}/{}",
153            self.context.host(),
154            NAMESPACE_ENDPOINT,
155            self.context.namespace(),
156            TRIGGERS_ENDPOINT,
157            trigger_name
158        );
159
160        let user_auth = self.context.auth();
161        let user = user_auth.0;
162        let pass = user_auth.1;
163
164        let request = match self.client.new_request(
165            Some(HttpMethods::GET),
166            url.as_str(),
167            Some((user, pass)),
168            None,
169        ) {
170            Ok(request) => request,
171            Err(err) => return Err(err),
172        };
173
174        let trigger: Trigger = match self.client.invoke_request(request) {
175            Ok(response) => match serde_json::from_value(response) {
176                Ok(trigger) => trigger,
177                Err(err) => return Err(format!("falied to deserilaize {}", err)),
178            },
179            Err(err) => return Err(format!("falied to insert trigger {}", err)),
180        };
181
182        Ok(trigger)
183    }
184
185    /// Deletes an already existing trigger
186    /// # Arguments
187    /// * `trigger_name` - String slice that holds trigger name
188    ///
189    pub fn delete(&self, trigger_name: &str) -> Result<Trigger, String> {
190        let url = format!(
191            "{}/api/v1/{}/{}/{}/{}",
192            self.context.host(),
193            NAMESPACE_ENDPOINT,
194            self.context.namespace(),
195            TRIGGERS_ENDPOINT,
196            trigger_name
197        );
198        let user_auth = self.context.auth();
199        let user = user_auth.0;
200        let pass = user_auth.1;
201
202        let request = match self.client.new_request(
203            Some(HttpMethods::DELETE),
204            url.as_str(),
205            Some((user, pass)),
206            None,
207        ) {
208            Ok(request) => request,
209            Err(err) => return Err(err),
210        };
211
212        let trigger: Trigger = match self.client.invoke_request(request) {
213            Ok(response) => match serde_json::from_value(response) {
214                Ok(trigger) => trigger,
215                Err(err) => return Err(format!("falied to deserilaize {}", err)),
216            },
217            Err(err) => return Err(format!("falied to insert trigger {}", err)),
218        };
219
220        Ok(trigger)
221    }
222
223    /// Fires a trigger to an action
224    ///
225    ///  # Arguments
226    /// * `trigger_name` - String slice that holds trigger name
227    /// * `payload` - payload is the result of the action
228    ///
229    pub fn fire(&self, trigger_name: &str, payload: Value) -> Result<Trigger, String> {
230        let url = format!(
231            "{}/api/v1/{}/{}/{}/{}",
232            self.context.host(),
233            NAMESPACE_ENDPOINT,
234            self.context.namespace(),
235            TRIGGERS_ENDPOINT,
236            trigger_name
237        );
238
239        let user_auth = self.context.auth();
240        let user = user_auth.0;
241        let pass = user_auth.1;
242
243        let request = match self.client.new_request(
244            Some(HttpMethods::POST),
245            url.as_str(),
246            Some((user, pass)),
247            Some(payload),
248        ) {
249            Ok(request) => request,
250            Err(err) => return Err(err),
251        };
252
253        let trigger: Trigger = match self.client.invoke_request(request) {
254            Ok(response) => match serde_json::from_value(response) {
255                Ok(trigger) => trigger,
256                Err(err) => return Err(format!("falied to deserilaize {}", err)),
257            },
258            Err(err) => return Err(format!("falied to insert trigger {}", err)),
259        };
260
261        Ok(trigger)
262    }
263}
openwhisk_client_rust/api/trigger.rs

openwhisk_client_rust/api/
trigger.rs
