datadog_api_client/datadogV2/api/
api_powerpack.rs

1// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
2// This product includes software developed at Datadog (https://www.datadoghq.com/).
3// Copyright 2019-Present Datadog, Inc.
4use crate::datadog;
5use async_stream::try_stream;
6use flate2::{
7    write::{GzEncoder, ZlibEncoder},
8    Compression,
9};
10use futures_core::stream::Stream;
11use reqwest::header::{HeaderMap, HeaderValue};
12use serde::{Deserialize, Serialize};
13use std::io::Write;
14
15/// ListPowerpacksOptionalParams is a struct for passing parameters to the method [`PowerpackAPI::list_powerpacks`]
16#[non_exhaustive]
17#[derive(Clone, Default, Debug)]
18pub struct ListPowerpacksOptionalParams {
19    /// Maximum number of powerpacks in the response.
20    pub page_limit: Option<i64>,
21    /// Specific offset to use as the beginning of the returned page.
22    pub page_offset: Option<i64>,
23}
24
25impl ListPowerpacksOptionalParams {
26    /// Maximum number of powerpacks in the response.
27    pub fn page_limit(mut self, value: i64) -> Self {
28        self.page_limit = Some(value);
29        self
30    }
31    /// Specific offset to use as the beginning of the returned page.
32    pub fn page_offset(mut self, value: i64) -> Self {
33        self.page_offset = Some(value);
34        self
35    }
36}
37
38/// CreatePowerpackError is a struct for typed errors of method [`PowerpackAPI::create_powerpack`]
39#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum CreatePowerpackError {
42    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
43    UnknownValue(serde_json::Value),
44}
45
46/// DeletePowerpackError is a struct for typed errors of method [`PowerpackAPI::delete_powerpack`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum DeletePowerpackError {
50    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
51    UnknownValue(serde_json::Value),
52}
53
54/// GetPowerpackError is a struct for typed errors of method [`PowerpackAPI::get_powerpack`]
55#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum GetPowerpackError {
58    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
59    UnknownValue(serde_json::Value),
60}
61
62/// ListPowerpacksError is a struct for typed errors of method [`PowerpackAPI::list_powerpacks`]
63#[derive(Debug, Clone, Serialize, Deserialize)]
64#[serde(untagged)]
65pub enum ListPowerpacksError {
66    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
67    UnknownValue(serde_json::Value),
68}
69
70/// UpdatePowerpackError is a struct for typed errors of method [`PowerpackAPI::update_powerpack`]
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum UpdatePowerpackError {
74    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
75    UnknownValue(serde_json::Value),
76}
77
78/// The Powerpack endpoints allow you to:
79///
80/// - Get a Powerpack
81/// - Create a Powerpack
82/// - Delete a Powerpack
83/// - Get a list of all Powerpacks
84///
85/// The Patch and Delete API methods can only be performed on a Powerpack by
86/// a user who has the powerpack create permission for that specific Powerpack.
87///
88/// Read [Scale Graphing Expertise with Powerpacks](<https://docs.datadoghq.com/dashboards/guide/powerpacks-best-practices/>) for more information.
89#[derive(Debug, Clone)]
90pub struct PowerpackAPI {
91    config: datadog::Configuration,
92    client: reqwest_middleware::ClientWithMiddleware,
93}
94
95impl Default for PowerpackAPI {
96    fn default() -> Self {
97        Self::with_config(datadog::Configuration::default())
98    }
99}
100
101impl PowerpackAPI {
102    pub fn new() -> Self {
103        Self::default()
104    }
105    pub fn with_config(config: datadog::Configuration) -> Self {
106        let mut reqwest_client_builder = reqwest::Client::builder();
107
108        if let Some(proxy_url) = &config.proxy_url {
109            let proxy = reqwest::Proxy::all(proxy_url).expect("Failed to parse proxy URL");
110            reqwest_client_builder = reqwest_client_builder.proxy(proxy);
111        }
112
113        let mut middleware_client_builder =
114            reqwest_middleware::ClientBuilder::new(reqwest_client_builder.build().unwrap());
115
116        if config.enable_retry {
117            struct RetryableStatus;
118            impl reqwest_retry::RetryableStrategy for RetryableStatus {
119                fn handle(
120                    &self,
121                    res: &Result<reqwest::Response, reqwest_middleware::Error>,
122                ) -> Option<reqwest_retry::Retryable> {
123                    match res {
124                        Ok(success) => reqwest_retry::default_on_request_success(success),
125                        Err(_) => None,
126                    }
127                }
128            }
129            let backoff_policy = reqwest_retry::policies::ExponentialBackoff::builder()
130                .build_with_max_retries(config.max_retries);
131
132            let retry_middleware =
133                reqwest_retry::RetryTransientMiddleware::new_with_policy_and_strategy(
134                    backoff_policy,
135                    RetryableStatus,
136                );
137
138            middleware_client_builder = middleware_client_builder.with(retry_middleware);
139        }
140
141        let client = middleware_client_builder.build();
142
143        Self { config, client }
144    }
145
146    pub fn with_client_and_config(
147        config: datadog::Configuration,
148        client: reqwest_middleware::ClientWithMiddleware,
149    ) -> Self {
150        Self { config, client }
151    }
152
153    /// Create a powerpack.
154    pub async fn create_powerpack(
155        &self,
156        body: crate::datadogV2::model::Powerpack,
157    ) -> Result<crate::datadogV2::model::PowerpackResponse, datadog::Error<CreatePowerpackError>>
158    {
159        match self.create_powerpack_with_http_info(body).await {
160            Ok(response_content) => {
161                if let Some(e) = response_content.entity {
162                    Ok(e)
163                } else {
164                    Err(datadog::Error::Serde(serde::de::Error::custom(
165                        "response content was None",
166                    )))
167                }
168            }
169            Err(err) => Err(err),
170        }
171    }
172
173    /// Create a powerpack.
174    pub async fn create_powerpack_with_http_info(
175        &self,
176        body: crate::datadogV2::model::Powerpack,
177    ) -> Result<
178        datadog::ResponseContent<crate::datadogV2::model::PowerpackResponse>,
179        datadog::Error<CreatePowerpackError>,
180    > {
181        let local_configuration = &self.config;
182        let operation_id = "v2.create_powerpack";
183
184        let local_client = &self.client;
185
186        let local_uri_str = format!(
187            "{}/api/v2/powerpacks",
188            local_configuration.get_operation_host(operation_id)
189        );
190        let mut local_req_builder =
191            local_client.request(reqwest::Method::POST, local_uri_str.as_str());
192
193        // build headers
194        let mut headers = HeaderMap::new();
195        headers.insert("Content-Type", HeaderValue::from_static("application/json"));
196        headers.insert("Accept", HeaderValue::from_static("application/json"));
197
198        // build user agent
199        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
200            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
201            Err(e) => {
202                log::warn!("Failed to parse user agent header: {e}, falling back to default");
203                headers.insert(
204                    reqwest::header::USER_AGENT,
205                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
206                )
207            }
208        };
209
210        // build auth
211        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
212            headers.insert(
213                "DD-API-KEY",
214                HeaderValue::from_str(local_key.key.as_str())
215                    .expect("failed to parse DD-API-KEY header"),
216            );
217        };
218        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
219            headers.insert(
220                "DD-APPLICATION-KEY",
221                HeaderValue::from_str(local_key.key.as_str())
222                    .expect("failed to parse DD-APPLICATION-KEY header"),
223            );
224        };
225
226        // build body parameters
227        let output = Vec::new();
228        let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter);
229        if body.serialize(&mut ser).is_ok() {
230            if let Some(content_encoding) = headers.get("Content-Encoding") {
231                match content_encoding.to_str().unwrap_or_default() {
232                    "gzip" => {
233                        let mut enc = GzEncoder::new(Vec::new(), Compression::default());
234                        let _ = enc.write_all(ser.into_inner().as_slice());
235                        match enc.finish() {
236                            Ok(buf) => {
237                                local_req_builder = local_req_builder.body(buf);
238                            }
239                            Err(e) => return Err(datadog::Error::Io(e)),
240                        }
241                    }
242                    "deflate" => {
243                        let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());
244                        let _ = enc.write_all(ser.into_inner().as_slice());
245                        match enc.finish() {
246                            Ok(buf) => {
247                                local_req_builder = local_req_builder.body(buf);
248                            }
249                            Err(e) => return Err(datadog::Error::Io(e)),
250                        }
251                    }
252                    "zstd1" => {
253                        let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap();
254                        let _ = enc.write_all(ser.into_inner().as_slice());
255                        match enc.finish() {
256                            Ok(buf) => {
257                                local_req_builder = local_req_builder.body(buf);
258                            }
259                            Err(e) => return Err(datadog::Error::Io(e)),
260                        }
261                    }
262                    _ => {
263                        local_req_builder = local_req_builder.body(ser.into_inner());
264                    }
265                }
266            } else {
267                local_req_builder = local_req_builder.body(ser.into_inner());
268            }
269        }
270
271        local_req_builder = local_req_builder.headers(headers);
272        let local_req = local_req_builder.build()?;
273        log::debug!("request content: {:?}", local_req.body());
274        let local_resp = local_client.execute(local_req).await?;
275
276        let local_status = local_resp.status();
277        let local_content = local_resp.text().await?;
278        log::debug!("response content: {}", local_content);
279
280        if !local_status.is_client_error() && !local_status.is_server_error() {
281            match serde_json::from_str::<crate::datadogV2::model::PowerpackResponse>(&local_content)
282            {
283                Ok(e) => {
284                    return Ok(datadog::ResponseContent {
285                        status: local_status,
286                        content: local_content,
287                        entity: Some(e),
288                    })
289                }
290                Err(e) => return Err(datadog::Error::Serde(e)),
291            };
292        } else {
293            let local_entity: Option<CreatePowerpackError> =
294                serde_json::from_str(&local_content).ok();
295            let local_error = datadog::ResponseContent {
296                status: local_status,
297                content: local_content,
298                entity: local_entity,
299            };
300            Err(datadog::Error::ResponseError(local_error))
301        }
302    }
303
304    /// Delete a powerpack.
305    pub async fn delete_powerpack(
306        &self,
307        powerpack_id: String,
308    ) -> Result<(), datadog::Error<DeletePowerpackError>> {
309        match self.delete_powerpack_with_http_info(powerpack_id).await {
310            Ok(_) => Ok(()),
311            Err(err) => Err(err),
312        }
313    }
314
315    /// Delete a powerpack.
316    pub async fn delete_powerpack_with_http_info(
317        &self,
318        powerpack_id: String,
319    ) -> Result<datadog::ResponseContent<()>, datadog::Error<DeletePowerpackError>> {
320        let local_configuration = &self.config;
321        let operation_id = "v2.delete_powerpack";
322
323        let local_client = &self.client;
324
325        let local_uri_str = format!(
326            "{}/api/v2/powerpacks/{powerpack_id}",
327            local_configuration.get_operation_host(operation_id),
328            powerpack_id = datadog::urlencode(powerpack_id)
329        );
330        let mut local_req_builder =
331            local_client.request(reqwest::Method::DELETE, local_uri_str.as_str());
332
333        // build headers
334        let mut headers = HeaderMap::new();
335        headers.insert("Accept", HeaderValue::from_static("*/*"));
336
337        // build user agent
338        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
339            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
340            Err(e) => {
341                log::warn!("Failed to parse user agent header: {e}, falling back to default");
342                headers.insert(
343                    reqwest::header::USER_AGENT,
344                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
345                )
346            }
347        };
348
349        // build auth
350        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
351            headers.insert(
352                "DD-API-KEY",
353                HeaderValue::from_str(local_key.key.as_str())
354                    .expect("failed to parse DD-API-KEY header"),
355            );
356        };
357        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
358            headers.insert(
359                "DD-APPLICATION-KEY",
360                HeaderValue::from_str(local_key.key.as_str())
361                    .expect("failed to parse DD-APPLICATION-KEY header"),
362            );
363        };
364
365        local_req_builder = local_req_builder.headers(headers);
366        let local_req = local_req_builder.build()?;
367        log::debug!("request content: {:?}", local_req.body());
368        let local_resp = local_client.execute(local_req).await?;
369
370        let local_status = local_resp.status();
371        let local_content = local_resp.text().await?;
372        log::debug!("response content: {}", local_content);
373
374        if !local_status.is_client_error() && !local_status.is_server_error() {
375            Ok(datadog::ResponseContent {
376                status: local_status,
377                content: local_content,
378                entity: None,
379            })
380        } else {
381            let local_entity: Option<DeletePowerpackError> =
382                serde_json::from_str(&local_content).ok();
383            let local_error = datadog::ResponseContent {
384                status: local_status,
385                content: local_content,
386                entity: local_entity,
387            };
388            Err(datadog::Error::ResponseError(local_error))
389        }
390    }
391
392    /// Get a powerpack.
393    pub async fn get_powerpack(
394        &self,
395        powerpack_id: String,
396    ) -> Result<crate::datadogV2::model::PowerpackResponse, datadog::Error<GetPowerpackError>> {
397        match self.get_powerpack_with_http_info(powerpack_id).await {
398            Ok(response_content) => {
399                if let Some(e) = response_content.entity {
400                    Ok(e)
401                } else {
402                    Err(datadog::Error::Serde(serde::de::Error::custom(
403                        "response content was None",
404                    )))
405                }
406            }
407            Err(err) => Err(err),
408        }
409    }
410
411    /// Get a powerpack.
412    pub async fn get_powerpack_with_http_info(
413        &self,
414        powerpack_id: String,
415    ) -> Result<
416        datadog::ResponseContent<crate::datadogV2::model::PowerpackResponse>,
417        datadog::Error<GetPowerpackError>,
418    > {
419        let local_configuration = &self.config;
420        let operation_id = "v2.get_powerpack";
421
422        let local_client = &self.client;
423
424        let local_uri_str = format!(
425            "{}/api/v2/powerpacks/{powerpack_id}",
426            local_configuration.get_operation_host(operation_id),
427            powerpack_id = datadog::urlencode(powerpack_id)
428        );
429        let mut local_req_builder =
430            local_client.request(reqwest::Method::GET, local_uri_str.as_str());
431
432        // build headers
433        let mut headers = HeaderMap::new();
434        headers.insert("Accept", HeaderValue::from_static("application/json"));
435
436        // build user agent
437        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
438            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
439            Err(e) => {
440                log::warn!("Failed to parse user agent header: {e}, falling back to default");
441                headers.insert(
442                    reqwest::header::USER_AGENT,
443                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
444                )
445            }
446        };
447
448        // build auth
449        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
450            headers.insert(
451                "DD-API-KEY",
452                HeaderValue::from_str(local_key.key.as_str())
453                    .expect("failed to parse DD-API-KEY header"),
454            );
455        };
456        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
457            headers.insert(
458                "DD-APPLICATION-KEY",
459                HeaderValue::from_str(local_key.key.as_str())
460                    .expect("failed to parse DD-APPLICATION-KEY header"),
461            );
462        };
463
464        local_req_builder = local_req_builder.headers(headers);
465        let local_req = local_req_builder.build()?;
466        log::debug!("request content: {:?}", local_req.body());
467        let local_resp = local_client.execute(local_req).await?;
468
469        let local_status = local_resp.status();
470        let local_content = local_resp.text().await?;
471        log::debug!("response content: {}", local_content);
472
473        if !local_status.is_client_error() && !local_status.is_server_error() {
474            match serde_json::from_str::<crate::datadogV2::model::PowerpackResponse>(&local_content)
475            {
476                Ok(e) => {
477                    return Ok(datadog::ResponseContent {
478                        status: local_status,
479                        content: local_content,
480                        entity: Some(e),
481                    })
482                }
483                Err(e) => return Err(datadog::Error::Serde(e)),
484            };
485        } else {
486            let local_entity: Option<GetPowerpackError> = serde_json::from_str(&local_content).ok();
487            let local_error = datadog::ResponseContent {
488                status: local_status,
489                content: local_content,
490                entity: local_entity,
491            };
492            Err(datadog::Error::ResponseError(local_error))
493        }
494    }
495
496    /// Get a list of all powerpacks.
497    pub async fn list_powerpacks(
498        &self,
499        params: ListPowerpacksOptionalParams,
500    ) -> Result<crate::datadogV2::model::ListPowerpacksResponse, datadog::Error<ListPowerpacksError>>
501    {
502        match self.list_powerpacks_with_http_info(params).await {
503            Ok(response_content) => {
504                if let Some(e) = response_content.entity {
505                    Ok(e)
506                } else {
507                    Err(datadog::Error::Serde(serde::de::Error::custom(
508                        "response content was None",
509                    )))
510                }
511            }
512            Err(err) => Err(err),
513        }
514    }
515
516    pub fn list_powerpacks_with_pagination(
517        &self,
518        mut params: ListPowerpacksOptionalParams,
519    ) -> impl Stream<
520        Item = Result<crate::datadogV2::model::PowerpackData, datadog::Error<ListPowerpacksError>>,
521    > + '_ {
522        try_stream! {
523            let mut page_size: i64 = 25;
524            if params.page_limit.is_none() {
525                params.page_limit = Some(page_size);
526            } else {
527                page_size = params.page_limit.unwrap().clone();
528            }
529            loop {
530                let resp = self.list_powerpacks(params.clone()).await?;
531                let Some(data) = resp.data else { break };
532
533                let r = data;
534                let count = r.len();
535                for team in r {
536                    yield team;
537                }
538
539                if count < page_size as usize {
540                    break;
541                }
542                if params.page_offset.is_none() {
543                    params.page_offset = Some(page_size.clone());
544                } else {
545                    params.page_offset = Some(params.page_offset.unwrap() + page_size.clone());
546                }
547            }
548        }
549    }
550
551    /// Get a list of all powerpacks.
552    pub async fn list_powerpacks_with_http_info(
553        &self,
554        params: ListPowerpacksOptionalParams,
555    ) -> Result<
556        datadog::ResponseContent<crate::datadogV2::model::ListPowerpacksResponse>,
557        datadog::Error<ListPowerpacksError>,
558    > {
559        let local_configuration = &self.config;
560        let operation_id = "v2.list_powerpacks";
561
562        // unbox and build optional parameters
563        let page_limit = params.page_limit;
564        let page_offset = params.page_offset;
565
566        let local_client = &self.client;
567
568        let local_uri_str = format!(
569            "{}/api/v2/powerpacks",
570            local_configuration.get_operation_host(operation_id)
571        );
572        let mut local_req_builder =
573            local_client.request(reqwest::Method::GET, local_uri_str.as_str());
574
575        if let Some(ref local_query_param) = page_limit {
576            local_req_builder =
577                local_req_builder.query(&[("page[limit]", &local_query_param.to_string())]);
578        };
579        if let Some(ref local_query_param) = page_offset {
580            local_req_builder =
581                local_req_builder.query(&[("page[offset]", &local_query_param.to_string())]);
582        };
583
584        // build headers
585        let mut headers = HeaderMap::new();
586        headers.insert("Accept", HeaderValue::from_static("application/json"));
587
588        // build user agent
589        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
590            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
591            Err(e) => {
592                log::warn!("Failed to parse user agent header: {e}, falling back to default");
593                headers.insert(
594                    reqwest::header::USER_AGENT,
595                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
596                )
597            }
598        };
599
600        // build auth
601        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
602            headers.insert(
603                "DD-API-KEY",
604                HeaderValue::from_str(local_key.key.as_str())
605                    .expect("failed to parse DD-API-KEY header"),
606            );
607        };
608        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
609            headers.insert(
610                "DD-APPLICATION-KEY",
611                HeaderValue::from_str(local_key.key.as_str())
612                    .expect("failed to parse DD-APPLICATION-KEY header"),
613            );
614        };
615
616        local_req_builder = local_req_builder.headers(headers);
617        let local_req = local_req_builder.build()?;
618        log::debug!("request content: {:?}", local_req.body());
619        let local_resp = local_client.execute(local_req).await?;
620
621        let local_status = local_resp.status();
622        let local_content = local_resp.text().await?;
623        log::debug!("response content: {}", local_content);
624
625        if !local_status.is_client_error() && !local_status.is_server_error() {
626            match serde_json::from_str::<crate::datadogV2::model::ListPowerpacksResponse>(
627                &local_content,
628            ) {
629                Ok(e) => {
630                    return Ok(datadog::ResponseContent {
631                        status: local_status,
632                        content: local_content,
633                        entity: Some(e),
634                    })
635                }
636                Err(e) => return Err(datadog::Error::Serde(e)),
637            };
638        } else {
639            let local_entity: Option<ListPowerpacksError> =
640                serde_json::from_str(&local_content).ok();
641            let local_error = datadog::ResponseContent {
642                status: local_status,
643                content: local_content,
644                entity: local_entity,
645            };
646            Err(datadog::Error::ResponseError(local_error))
647        }
648    }
649
650    /// Update a powerpack.
651    pub async fn update_powerpack(
652        &self,
653        powerpack_id: String,
654        body: crate::datadogV2::model::Powerpack,
655    ) -> Result<crate::datadogV2::model::PowerpackResponse, datadog::Error<UpdatePowerpackError>>
656    {
657        match self
658            .update_powerpack_with_http_info(powerpack_id, body)
659            .await
660        {
661            Ok(response_content) => {
662                if let Some(e) = response_content.entity {
663                    Ok(e)
664                } else {
665                    Err(datadog::Error::Serde(serde::de::Error::custom(
666                        "response content was None",
667                    )))
668                }
669            }
670            Err(err) => Err(err),
671        }
672    }
673
674    /// Update a powerpack.
675    pub async fn update_powerpack_with_http_info(
676        &self,
677        powerpack_id: String,
678        body: crate::datadogV2::model::Powerpack,
679    ) -> Result<
680        datadog::ResponseContent<crate::datadogV2::model::PowerpackResponse>,
681        datadog::Error<UpdatePowerpackError>,
682    > {
683        let local_configuration = &self.config;
684        let operation_id = "v2.update_powerpack";
685
686        let local_client = &self.client;
687
688        let local_uri_str = format!(
689            "{}/api/v2/powerpacks/{powerpack_id}",
690            local_configuration.get_operation_host(operation_id),
691            powerpack_id = datadog::urlencode(powerpack_id)
692        );
693        let mut local_req_builder =
694            local_client.request(reqwest::Method::PATCH, local_uri_str.as_str());
695
696        // build headers
697        let mut headers = HeaderMap::new();
698        headers.insert("Content-Type", HeaderValue::from_static("application/json"));
699        headers.insert("Accept", HeaderValue::from_static("application/json"));
700
701        // build user agent
702        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
703            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
704            Err(e) => {
705                log::warn!("Failed to parse user agent header: {e}, falling back to default");
706                headers.insert(
707                    reqwest::header::USER_AGENT,
708                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
709                )
710            }
711        };
712
713        // build auth
714        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
715            headers.insert(
716                "DD-API-KEY",
717                HeaderValue::from_str(local_key.key.as_str())
718                    .expect("failed to parse DD-API-KEY header"),
719            );
720        };
721        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
722            headers.insert(
723                "DD-APPLICATION-KEY",
724                HeaderValue::from_str(local_key.key.as_str())
725                    .expect("failed to parse DD-APPLICATION-KEY header"),
726            );
727        };
728
729        // build body parameters
730        let output = Vec::new();
731        let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter);
732        if body.serialize(&mut ser).is_ok() {
733            if let Some(content_encoding) = headers.get("Content-Encoding") {
734                match content_encoding.to_str().unwrap_or_default() {
735                    "gzip" => {
736                        let mut enc = GzEncoder::new(Vec::new(), Compression::default());
737                        let _ = enc.write_all(ser.into_inner().as_slice());
738                        match enc.finish() {
739                            Ok(buf) => {
740                                local_req_builder = local_req_builder.body(buf);
741                            }
742                            Err(e) => return Err(datadog::Error::Io(e)),
743                        }
744                    }
745                    "deflate" => {
746                        let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());
747                        let _ = enc.write_all(ser.into_inner().as_slice());
748                        match enc.finish() {
749                            Ok(buf) => {
750                                local_req_builder = local_req_builder.body(buf);
751                            }
752                            Err(e) => return Err(datadog::Error::Io(e)),
753                        }
754                    }
755                    "zstd1" => {
756                        let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap();
757                        let _ = enc.write_all(ser.into_inner().as_slice());
758                        match enc.finish() {
759                            Ok(buf) => {
760                                local_req_builder = local_req_builder.body(buf);
761                            }
762                            Err(e) => return Err(datadog::Error::Io(e)),
763                        }
764                    }
765                    _ => {
766                        local_req_builder = local_req_builder.body(ser.into_inner());
767                    }
768                }
769            } else {
770                local_req_builder = local_req_builder.body(ser.into_inner());
771            }
772        }
773
774        local_req_builder = local_req_builder.headers(headers);
775        let local_req = local_req_builder.build()?;
776        log::debug!("request content: {:?}", local_req.body());
777        let local_resp = local_client.execute(local_req).await?;
778
779        let local_status = local_resp.status();
780        let local_content = local_resp.text().await?;
781        log::debug!("response content: {}", local_content);
782
783        if !local_status.is_client_error() && !local_status.is_server_error() {
784            match serde_json::from_str::<crate::datadogV2::model::PowerpackResponse>(&local_content)
785            {
786                Ok(e) => {
787                    return Ok(datadog::ResponseContent {
788                        status: local_status,
789                        content: local_content,
790                        entity: Some(e),
791                    })
792                }
793                Err(e) => return Err(datadog::Error::Serde(e)),
794            };
795        } else {
796            let local_entity: Option<UpdatePowerpackError> =
797                serde_json::from_str(&local_content).ok();
798            let local_error = datadog::ResponseContent {
799                status: local_status,
800                content: local_content,
801                entity: local_entity,
802            };
803            Err(datadog::Error::ResponseError(local_error))
804        }
805    }
806}
datadog_api_client/datadogV2/api/api_powerpack.rs

datadog_api_client/datadogV2/api/
api_powerpack.rs
