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

openwhisk_rust/api/
trigger.rs
