Add CSM Agentless Read Endpoint

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2024-12-18 19:23:38.680515",
-            "spec_repo_commit": "3f22290a"
+            "regenerated": "2024-12-19 11:45:54.928880",
+            "spec_repo_commit": "e2cc2df0"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2024-12-18 19:23:38.695560",
-            "spec_repo_commit": "3f22290a"
+            "regenerated": "2024-12-19 11:45:54.945568",
+            "spec_repo_commit": "e2cc2df0"
         }
     }
 }

.generator/schemas/v2/openapi.yaml

@@ -2615,6 +2615,57 @@ components:
             $ref: '#/components/schemas/AwsCURConfig'
           type: array
       type: object
+    AwsScanOptionsAttributes:
+      description: Attributes for the AWS scan options.
+      properties:
+        lambda:
+          description: Indicates if scanning of Lambda functions is enabled.
+          example: true
+          type: boolean
+        sensitive_data:
+          description: Indicates if scanning for sensitive data is enabled.
+          example: false
+          type: boolean
+        vuln_containers_os:
+          description: Indicates if scanning for vulnerabilities in containers is
+            enabled.
+          example: true
+          type: boolean
+        vuln_host_os:
+          description: Indicates if scanning for vulnerabilities in hosts is enabled.
+          example: true
+          type: boolean
+      type: object
+    AwsScanOptionsData:
+      description: Single AWS Scan Options entry.
+      properties:
+        attributes:
+          $ref: '#/components/schemas/AwsScanOptionsAttributes'
+        id:
+          description: The ID of the AWS account.
+          example: '184366314700'
+          type: string
+        type:
+          $ref: '#/components/schemas/AwsScanOptionsType'
+      type: object
+    AwsScanOptionsResponse:
+      description: Response object that includes a list of AWS scan options.
+      properties:
+        data:
+          description: A list of AWS scan options.
+          items:
+            $ref: '#/components/schemas/AwsScanOptionsData'
+          type: array
+      type: object
+    AwsScanOptionsType:
+      default: aws_scan_options
+      description: The type of the resource. The value should always be `aws_scan_options`.
+      enum:
+      - aws_scan_options
+      example: aws_scan_options
+      type: string
+      x-enum-varnames:
+      - AWS_SCAN_OPTIONS
     AzureUCConfig:
       description: Azure config.
       properties:
@@ -29269,6 +29320,24 @@ info:
   version: '1.0'
 openapi: 3.0.0
 paths:
+  /api/v2/agentless_scanning/accounts/aws:
+    get:
+      description: Fetches the scan options configured for AWS accounts.
+      operationId: ListAwsScanOptions
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/AwsScanOptionsResponse'
+          description: OK
+        '403':
+          $ref: '#/components/responses/NotAuthorizedResponse'
+        '429':
+          $ref: '#/components/responses/TooManyRequestsResponse'
+      summary: Get AWS Scan Options
+      tags:
+      - Agentless Scanning
   /api/v2/api_keys:
     get:
       description: List all API keys available for your account.
@@ -46531,6 +46600,11 @@ tags:
   externalDocs:
     url: https://docs.datadoghq.com/integrations/amazon_web_services/#log-collection
   name: AWS Logs Integration
+- description: "Datadog Agentless Scanning provides visibility into risks and vulnerabilities\nwithin
+    your hosts, running containers, and serverless functions\u2014all without\nrequiring
+    teams to install Agents on every host or where Agents cannot be installed.\nGo
+    to https://www.datadoghq.com/blog/agentless-scanning/ to learn more"
+  name: Agentless Scanning
 - description: Deploy and disable apps in App Builder.
   name: App Deployment
 - description: Create, read, update, and delete apps in App Builder.

examples/v2_agentless-scanning_ListAwsScanOptions.rs

@@ -0,0 +1,15 @@
+// Get AWS Scan Options returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_agentless_scanning::AgentlessScanningAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = AgentlessScanningAPI::with_config(configuration);
+    let resp = api.list_aws_scan_options().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV2/api/api_agentless_scanning.rs

@@ -0,0 +1,189 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+use crate::datadog;
+use reqwest::header::{HeaderMap, HeaderValue};
+use serde::{Deserialize, Serialize};
+
+/// ListAwsScanOptionsError is a struct for typed errors of method [`AgentlessScanningAPI::list_aws_scan_options`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ListAwsScanOptionsError {
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
+/// Datadog Agentless Scanning provides visibility into risks and vulnerabilities
+/// within your hosts, running containers, and serverless functions—all without
+/// requiring teams to install Agents on every host or where Agents cannot be installed.
+/// Go to <https://www.datadoghq.com/blog/agentless-scanning/> to learn more
+#[derive(Debug, Clone)]
+pub struct AgentlessScanningAPI {
+    config: datadog::Configuration,
+    client: reqwest_middleware::ClientWithMiddleware,
+}
+
+impl Default for AgentlessScanningAPI {
+    fn default() -> Self {
+        Self::with_config(datadog::Configuration::default())
+    }
+}
+
+impl AgentlessScanningAPI {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn with_config(config: datadog::Configuration) -> Self {
+        let mut reqwest_client_builder = reqwest::Client::builder();
+
+        if let Some(proxy_url) = &config.proxy_url {
+            let proxy = reqwest::Proxy::all(proxy_url).expect("Failed to parse proxy URL");
+            reqwest_client_builder = reqwest_client_builder.proxy(proxy);
+        }
+
+        let mut middleware_client_builder =
+            reqwest_middleware::ClientBuilder::new(reqwest_client_builder.build().unwrap());
+
+        if config.enable_retry {
+            struct RetryableStatus;
+            impl reqwest_retry::RetryableStrategy for RetryableStatus {
+                fn handle(
+                    &self,
+                    res: &Result<reqwest::Response, reqwest_middleware::Error>,
+                ) -> Option<reqwest_retry::Retryable> {
+                    match res {
+                        Ok(success) => reqwest_retry::default_on_request_success(success),
+                        Err(_) => None,
+                    }
+                }
+            }
+            let backoff_policy = reqwest_retry::policies::ExponentialBackoff::builder()
+                .build_with_max_retries(config.max_retries);
+
+            let retry_middleware =
+                reqwest_retry::RetryTransientMiddleware::new_with_policy_and_strategy(
+                    backoff_policy,
+                    RetryableStatus,
+                );
+
+            middleware_client_builder = middleware_client_builder.with(retry_middleware);
+        }
+
+        let client = middleware_client_builder.build();
+
+        Self { config, client }
+    }
+
+    pub fn with_client_and_config(
+        config: datadog::Configuration,
+        client: reqwest_middleware::ClientWithMiddleware,
+    ) -> Self {
+        Self { config, client }
+    }
+
+    /// Fetches the scan options configured for AWS accounts.
+    pub async fn list_aws_scan_options(
+        &self,
+    ) -> Result<
+        crate::datadogV2::model::AwsScanOptionsResponse,
+        datadog::Error<ListAwsScanOptionsError>,
+    > {
+        match self.list_aws_scan_options_with_http_info().await {
+            Ok(response_content) => {
+                if let Some(e) = response_content.entity {
+                    Ok(e)
+                } else {
+                    Err(datadog::Error::Serde(serde::de::Error::custom(
+                        "response content was None",
+                    )))
+                }
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    /// Fetches the scan options configured for AWS accounts.
+    pub async fn list_aws_scan_options_with_http_info(
+        &self,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV2::model::AwsScanOptionsResponse>,
+        datadog::Error<ListAwsScanOptionsError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v2.list_aws_scan_options";
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v2/agentless_scanning/accounts/aws",
+            local_configuration.get_operation_host(operation_id)
+        );
+        let mut local_req_builder =
+            local_client.request(reqwest::Method::GET, local_uri_str.as_str());
+
+        // build headers
+        let mut headers = HeaderMap::new();
+        headers.insert("Accept", HeaderValue::from_static("application/json"));
+
+        // build user agent
+        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
+            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
+            Err(e) => {
+                log::warn!("Failed to parse user agent header: {e}, falling back to default");
+                headers.insert(
+                    reqwest::header::USER_AGENT,
+                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
+                )
+            }
+        };
+
+        // build auth
+        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
+            headers.insert(
+                "DD-API-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-API-KEY header"),
+            );
+        };
+        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
+            headers.insert(
+                "DD-APPLICATION-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-APPLICATION-KEY header"),
+            );
+        };
+
+        local_req_builder = local_req_builder.headers(headers);
+        let local_req = local_req_builder.build()?;
+        log::debug!("request content: {:?}", local_req.body());
+        let local_resp = local_client.execute(local_req).await?;
+
+        let local_status = local_resp.status();
+        let local_content = local_resp.text().await?;
+        log::debug!("response content: {}", local_content);
+
+        if !local_status.is_client_error() && !local_status.is_server_error() {
+            match serde_json::from_str::<crate::datadogV2::model::AwsScanOptionsResponse>(
+                &local_content,
+            ) {
+                Ok(e) => {
+                    return Ok(datadog::ResponseContent {
+                        status: local_status,
+                        content: local_content,
+                        entity: Some(e),
+                    })
+                }
+                Err(e) => return Err(datadog::Error::Serde(e)),
+            };
+        } else {
+            let local_entity: Option<ListAwsScanOptionsError> =
+                serde_json::from_str(&local_content).ok();
+            let local_error = datadog::ResponseContent {
+                status: local_status,
+                content: local_content,
+                entity: local_entity,
+            };
+            Err(datadog::Error::ResponseError(local_error))
+        }
+    }
+}

src/datadogV2/api/mod.rs

@@ -2,6 +2,7 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
+pub mod api_agentless_scanning;
 pub mod api_api_management;
 pub mod api_apm_retention_filters;
 pub mod api_app_deployment;

src/datadogV2/mod.rs

@@ -3,6 +3,7 @@
 // Copyright 2019-Present Datadog, Inc.
 
 pub mod api;
+pub use self::api::api_agentless_scanning;
 pub use self::api::api_api_management;
 pub use self::api::api_apm_retention_filters;
 pub use self::api::api_app_deployment;

src/datadogV2/model/mod.rs

@@ -2,6 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
+pub mod model_aws_scan_options_response;
+pub use self::model_aws_scan_options_response::AwsScanOptionsResponse;
+pub mod model_aws_scan_options_data;
+pub use self::model_aws_scan_options_data::AwsScanOptionsData;
+pub mod model_aws_scan_options_attributes;
+pub use self::model_aws_scan_options_attributes::AwsScanOptionsAttributes;
+pub mod model_aws_scan_options_type;
+pub use self::model_aws_scan_options_type::AwsScanOptionsType;
+pub mod model_api_error_response;
+pub use self::model_api_error_response::APIErrorResponse;
 pub mod model_api_keys_sort;
 pub use self::model_api_keys_sort::APIKeysSort;
 pub mod model_api_keys_response;
@@ -58,8 +68,6 @@ pub mod model_api_keys_response_meta;
 pub use self::model_api_keys_response_meta::APIKeysResponseMeta;
 pub mod model_api_keys_response_meta_page;
 pub use self::model_api_keys_response_meta_page::APIKeysResponseMetaPage;
-pub mod model_api_error_response;
-pub use self::model_api_error_response::APIErrorResponse;
 pub mod model_api_key_create_request;
 pub use self::model_api_key_create_request::APIKeyCreateRequest;
 pub mod model_api_key_create_data;