Skip to main content

conductor/client/
orkes_metadata_client.rs

1// Copyright {{.Year}} Conductor OSS
2// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3
4use std::ops::Deref;
5use tracing::{debug, info};
6
7use crate::error::Result;
8use crate::http::{ApiClient, ApiPath};
9use crate::models::MetadataTag;
10
11use super::MetadataClient;
12
13/// Extended metadata client with Orkes-specific features (tagging APIs).
14///
15/// This client provides all the functionality of `MetadataClient` plus
16/// tagging capabilities for workflows and tasks. Use `Deref` to access
17/// base methods transparently.
18///
19/// # Example
20///
21/// ```rust,ignore
22/// let orkes_metadata = client.orkes_metadata_client();
23///
24/// // Access base methods via Deref
25/// orkes_metadata.register_workflow_def(&workflow).await?;
26///
27/// // Use Orkes-specific tagging methods
28/// let tag = MetadataTag::with_value("env", "production");
29/// orkes_metadata.add_workflow_tag("my-workflow", &tag).await?;
30/// ```
31#[derive(Clone)]
32pub struct OrkesMetadataClient {
33    inner: MetadataClient,
34    api: ApiClient,
35}
36
37impl Deref for OrkesMetadataClient {
38    type Target = MetadataClient;
39
40    fn deref(&self) -> &Self::Target {
41        &self.inner
42    }
43}
44
45impl OrkesMetadataClient {
46    /// Create a new Orkes metadata client.
47    #[must_use]
48    pub fn new(api: ApiClient) -> Self {
49        Self {
50            inner: MetadataClient::new(api.clone()),
51            api,
52        }
53    }
54
55    // ==================== Workflow Tags ====================
56
57    /// Add a tag to a workflow definition.
58    ///
59    /// # Errors
60    ///
61    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, or an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status.
62    pub async fn add_workflow_tag(&self, workflow_name: &str, tag: &MetadataTag) -> Result<()> {
63        debug!(
64            workflow_name = %workflow_name,
65            tag_key = %tag.key,
66            "Adding workflow tag"
67        );
68
69        let path = format!("/metadata/workflow/{workflow_name}/tags");
70        self.api
71            .post_no_response(
72                ApiPath::templated(&path, "/metadata/workflow/{workflowName}/tags"),
73                &[tag],
74            )
75            .await?;
76
77        info!(
78            workflow_name = %workflow_name,
79            tag_key = %tag.key,
80            "Workflow tag added"
81        );
82
83        Ok(())
84    }
85
86    /// Get all tags for a workflow definition.
87    ///
88    /// # Errors
89    ///
90    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status, or [`crate::error::ConductorError::Json`] if the response body can't be deserialized.
91    pub async fn get_workflow_tags(&self, workflow_name: &str) -> Result<Vec<MetadataTag>> {
92        let path = format!("/metadata/workflow/{workflow_name}/tags");
93        self.api
94            .get(ApiPath::templated(
95                &path,
96                "/metadata/workflow/{workflowName}/tags",
97            ))
98            .await
99    }
100
101    /// Set tags for a workflow definition (replaces existing tags).
102    ///
103    /// # Errors
104    ///
105    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, or an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status.
106    pub async fn set_workflow_tags(&self, workflow_name: &str, tags: &[MetadataTag]) -> Result<()> {
107        debug!(
108            workflow_name = %workflow_name,
109            tag_count = tags.len(),
110            "Setting workflow tags"
111        );
112
113        let path = format!("/metadata/workflow/{workflow_name}/tags");
114        self.api
115            .put_no_response(
116                ApiPath::templated(&path, "/metadata/workflow/{workflowName}/tags"),
117                tags,
118            )
119            .await?;
120
121        info!(
122            workflow_name = %workflow_name,
123            tag_count = tags.len(),
124            "Workflow tags set"
125        );
126
127        Ok(())
128    }
129
130    /// Delete a tag from a workflow definition.
131    ///
132    /// # Errors
133    ///
134    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status, or [`crate::error::ConductorError::Json`] if the response body can't be deserialized.
135    pub async fn delete_workflow_tag(&self, workflow_name: &str, tag: &MetadataTag) -> Result<()> {
136        debug!(
137            workflow_name = %workflow_name,
138            tag_key = %tag.key,
139            "Deleting workflow tag"
140        );
141
142        let path = format!("/metadata/workflow/{workflow_name}/tags");
143        self.api
144            .delete_with_body(
145                ApiPath::templated(&path, "/metadata/workflow/{workflowName}/tags"),
146                &[tag],
147            )
148            .await?;
149
150        info!(
151            workflow_name = %workflow_name,
152            tag_key = %tag.key,
153            "Workflow tag deleted"
154        );
155
156        Ok(())
157    }
158
159    // ==================== Task Tags ====================
160
161    /// Add a tag to a task definition.
162    ///
163    /// # Errors
164    ///
165    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, or an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status.
166    pub async fn add_task_tag(&self, task_name: &str, tag: &MetadataTag) -> Result<()> {
167        debug!(
168            task_name = %task_name,
169            tag_key = %tag.key,
170            "Adding task tag"
171        );
172
173        let path = format!("/metadata/taskdefs/{task_name}/tags");
174        self.api
175            .post_no_response(
176                ApiPath::templated(&path, "/metadata/taskdefs/{taskName}/tags"),
177                &[tag],
178            )
179            .await?;
180
181        info!(
182            task_name = %task_name,
183            tag_key = %tag.key,
184            "Task tag added"
185        );
186
187        Ok(())
188    }
189
190    /// Get all tags for a task definition.
191    ///
192    /// # Errors
193    ///
194    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status, or [`crate::error::ConductorError::Json`] if the response body can't be deserialized.
195    pub async fn get_task_tags(&self, task_name: &str) -> Result<Vec<MetadataTag>> {
196        let path = format!("/metadata/taskdefs/{task_name}/tags");
197        self.api
198            .get(ApiPath::templated(
199                &path,
200                "/metadata/taskdefs/{taskName}/tags",
201            ))
202            .await
203    }
204
205    /// Set tags for a task definition (replaces existing tags).
206    ///
207    /// # Errors
208    ///
209    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, or an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status.
210    pub async fn set_task_tags(&self, task_name: &str, tags: &[MetadataTag]) -> Result<()> {
211        debug!(
212            task_name = %task_name,
213            tag_count = tags.len(),
214            "Setting task tags"
215        );
216
217        let path = format!("/metadata/taskdefs/{task_name}/tags");
218        self.api
219            .put_no_response(
220                ApiPath::templated(&path, "/metadata/taskdefs/{taskName}/tags"),
221                tags,
222            )
223            .await?;
224
225        info!(
226            task_name = %task_name,
227            tag_count = tags.len(),
228            "Task tags set"
229        );
230
231        Ok(())
232    }
233
234    /// Delete a tag from a task definition.
235    ///
236    /// # Errors
237    ///
238    /// Returns [`crate::error::ConductorError::Http`] if the request fails at the transport level, an [`crate::error::ConductorError::Auth`]/[`crate::error::ConductorError::Api`]/[`crate::error::ConductorError::Server`] variant if the server responds with a non-2xx status, or [`crate::error::ConductorError::Json`] if the response body can't be deserialized.
239    pub async fn delete_task_tag(&self, task_name: &str, tag: &MetadataTag) -> Result<()> {
240        debug!(
241            task_name = %task_name,
242            tag_key = %tag.key,
243            "Deleting task tag"
244        );
245
246        let path = format!("/metadata/taskdefs/{task_name}/tags");
247        self.api
248            .delete_with_body(
249                ApiPath::templated(&path, "/metadata/taskdefs/{taskName}/tags"),
250                &[tag],
251            )
252            .await?;
253
254        info!(
255            task_name = %task_name,
256            tag_key = %tag.key,
257            "Task tag deleted"
258        );
259
260        Ok(())
261    }
262}
263
264#[cfg(test)]
265mod tests {
266    use super::*;
267    use crate::Configuration;
268
269    #[test]
270    fn test_orkes_metadata_client_creation() {
271        let config = Configuration::new("http://localhost:8080/api");
272        let api = ApiClient::new(config).unwrap();
273        let _client = OrkesMetadataClient::new(api);
274    }
275
276    #[test]
277    fn test_deref_to_metadata_client() {
278        let config = Configuration::new("http://localhost:8080/api");
279        let api = ApiClient::new(config).unwrap();
280        let orkes_client = OrkesMetadataClient::new(api);
281
282        // Access inner MetadataClient via Deref
283        let _metadata_ref: &MetadataClient = &orkes_client;
284    }
285}