scm-sdk 0.1.1

Native async Strata Cloud Manager SDK, beginning with Prisma AIRS
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Network Broker channels use their explicitly configured, distinct endpoint.
use super::{
    common,
    models::{
        Channel, ChannelListResponse, ChannelStats, CreateChannelRequest, UpdateChannelRequest,
    },
};
use crate::{Client, Error, ErrorKind, RawRequest, RequestOptions, Result};
use http::Method;
const PATH: &str = "/v1/channels";

#[derive(Clone, Default)]
#[non_exhaustive]
pub struct ChannelListOptions {
    pub skip: Option<u64>,
    pub limit: Option<u32>,
    pub search: Option<String>,
    /// Each status is sent separately in caller order, including duplicates.
    pub status: Vec<String>,
    pub include_all_if_empty: Option<bool>,
}
crate::redaction::redacted_debug!(ChannelListOptions);
#[derive(Clone, Debug)]
pub struct RedTeamNetworkBrokerClient {
    pub(super) client: Client,
}
impl RedTeamNetworkBrokerClient {
    pub fn new(client: Client) -> Result<Self> {
        client.require_auth(crate::engine::AuthKind::OAuth)?;
        Ok(Self {
            client: client.with_tsg_header(false)?,
        })
    }
    pub fn client(&self) -> &Client {
        &self.client
    }
    pub async fn list_channels(
        &self,
        params: &ChannelListOptions,
        options: Option<&RequestOptions>,
    ) -> Result<ChannelListResponse> {
        if params.status.len() > 252 {
            return Err(Error::new(ErrorKind::Limit));
        }
        let mut query = common::listing(params.skip, params.limit, params.search.as_deref())?;
        for status in &params.status {
            common::filter(status)?;
            query.push(("status".into(), status.clone()));
        }
        if let Some(value) = params.include_all_if_empty {
            query.push(("include_all_if_empty".into(), value.to_string()));
        }
        self.client
            .send_contract(
                RawRequest::read(PATH)
                    .query(query)
                    .named("red_team.network_broker.list_channels"),
                "ChannelListResponseSchema",
                options,
            )
            .await
    }
    pub async fn create_channel(
        &self,
        body: &CreateChannelRequest,
        options: Option<&RequestOptions>,
    ) -> Result<Channel> {
        self.client
            .send_model(
                RawRequest::new(Method::POST, PATH).named("red_team.network_broker.create_channel"),
                body,
                "CreateChannelRequestSchema",
                "ChannelSchema",
                options,
            )
            .await
    }
    pub async fn get_channel_stats(
        &self,
        options: Option<&RequestOptions>,
    ) -> Result<ChannelStats> {
        self.client
            .send_contract(
                RawRequest::read("/v1/channels/stats")
                    .named("red_team.network_broker.get_channel_stats"),
                "ChannelStatsSchema",
                options,
            )
            .await
    }
    pub async fn get_channel(
        &self,
        uuid: &str,
        options: Option<&RequestOptions>,
    ) -> Result<Channel> {
        common::uuid(uuid)?;
        self.client
            .send_contract(
                RawRequest::read(PATH)
                    .segment(uuid)?
                    .named("red_team.network_broker.get_channel"),
                "ChannelSchema",
                options,
            )
            .await
    }
    /// Ordinary JSON PATCH; this endpoint does not use JSON merge-patch media type.
    pub async fn update_channel(
        &self,
        uuid: &str,
        body: &UpdateChannelRequest,
        options: Option<&RequestOptions>,
    ) -> Result<Channel> {
        common::uuid(uuid)?;
        self.client
            .send_model(
                RawRequest::new(Method::PATCH, PATH)
                    .segment(uuid)?
                    .named("red_team.network_broker.update_channel"),
                body,
                "UpdateChannelRequestSchema",
                "ChannelSchema",
                options,
            )
            .await
    }
}