1use std::str::FromStr;
16
17use crate::{
18 auth::AuthContext,
19 error::{
20 Result,
21 SdkApiError,
22 SdkError,
23 },
24 metadata::CallProperties,
25 util::make_request_with_metadata,
26};
27
28use cx_api::proto::com::coralogix::quota::v1::{
29 CreatePolicyRequest,
30 CreatePolicyResponse,
31 DeletePolicyRequest,
32 DeletePolicyResponse,
33 GetCompanyPoliciesRequest,
34 GetCompanyPoliciesResponse,
35 GetPolicyRequest,
36 GetPolicyResponse,
37 UpdatePolicyRequest,
38 UpdatePolicyResponse,
39 policies_service_client::PoliciesServiceClient,
40 update_policy_request,
41};
42use tokio::sync::Mutex;
43use tonic::{
44 metadata::MetadataMap,
45 transport::{
46 Channel,
47 ClientTlsConfig,
48 Endpoint,
49 },
50};
51
52pub use cx_api::proto::com::coralogix::quota::v1::{
53 ArchiveRetention,
54 LogRules,
55 Rule,
56 RuleTypeId,
57 SourceType,
58 SpanRules,
59 create_policy_request::SourceTypeRules,
60};
61
62fn convert_source_types(a: SourceTypeRules) -> update_policy_request::SourceTypeRules {
63 match a {
64 SourceTypeRules::LogRules(r) => update_policy_request::SourceTypeRules::LogRules(r),
65 SourceTypeRules::SpanRules(r) => update_policy_request::SourceTypeRules::SpanRules(r),
66 }
67}
68
69use crate::CoralogixRegion;
70
71const TCO_FEATURE_GROUP_ID: &str = "tco";
72
73pub struct TcoPoliciesClient {
76 metadata_map: MetadataMap,
77 service_client: Mutex<PoliciesServiceClient<Channel>>,
78}
79
80impl TcoPoliciesClient {
81 pub fn new(auth_context: AuthContext, region: CoralogixRegion) -> Result<Self> {
87 let channel: Channel = Endpoint::from_str(region.grpc_endpoint().as_str())?
88 .tls_config(ClientTlsConfig::new().with_native_roots())?
89 .connect_lazy();
90 let request_metadata: CallProperties = (&auth_context.team_level_api_key).into();
91 Ok(Self {
92 metadata_map: request_metadata.to_metadata_map(),
93 service_client: Mutex::new(PoliciesServiceClient::new(channel)),
94 })
95 }
96
97 #[allow(clippy::too_many_arguments)]
108 pub async fn create(
109 &self,
110 name: Option<String>,
111 description: Option<String>,
112 priority: i32,
113 application_rule: Option<Rule>,
114 subsystem_rule: Option<Rule>,
115 archive_retention: Option<ArchiveRetention>,
116 source_type_rules: Option<SourceTypeRules>,
117 ) -> Result<CreatePolicyResponse> {
118 let request = make_request_with_metadata(
119 CreatePolicyRequest {
120 name,
121 description,
122 priority,
123 application_rule,
124 subsystem_rule,
125 archive_retention,
126 source_type_rules,
127 },
128 &self.metadata_map,
129 );
130 self.service_client
131 .lock()
132 .await
133 .create_policy(request)
134 .await
135 .map(|r| r.into_inner())
136 .map_err(|status| {
137 SdkError::ApiError(SdkApiError {
138 status,
139 endpoint: "/com.coralogixapis.quota.v1.PoliciesService/CreatePolicy".into(),
140 feature_group: TCO_FEATURE_GROUP_ID.into(),
141 })
142 })
143 }
144
145 #[allow(clippy::too_many_arguments)]
157 pub async fn update(
158 &self,
159 id: String,
160 name: Option<String>,
161 description: Option<String>,
162 priority: i32,
163 application_rule: Option<Rule>,
164 subsystem_rule: Option<Rule>,
165 archive_retention: Option<ArchiveRetention>,
166 enabled: Option<bool>,
167 source_type_rules: Option<SourceTypeRules>,
168 ) -> Result<UpdatePolicyResponse> {
169 let request = make_request_with_metadata(
170 UpdatePolicyRequest {
171 id: Some(id),
172 name,
173 description,
174 priority,
175 application_rule,
176 subsystem_rule,
177 archive_retention,
178 enabled,
179 source_type_rules: source_type_rules.map(convert_source_types),
180 },
181 &self.metadata_map,
182 );
183 self.service_client
184 .lock()
185 .await
186 .update_policy(request)
187 .await
188 .map(|r| r.into_inner())
189 .map_err(|status| {
190 SdkError::ApiError(SdkApiError {
191 status,
192 endpoint: "/com.coralogixapis.quota.v1.PoliciesService/UpdatePolicy".into(),
193 feature_group: TCO_FEATURE_GROUP_ID.into(),
194 })
195 })
196 }
197
198 pub async fn delete(&self, id: String) -> Result<DeletePolicyResponse> {
203 let request =
204 make_request_with_metadata(DeletePolicyRequest { id: Some(id) }, &self.metadata_map);
205 self.service_client
206 .lock()
207 .await
208 .delete_policy(request)
209 .await
210 .map(|r| r.into_inner())
211 .map_err(|status| {
212 SdkError::ApiError(SdkApiError {
213 status,
214 endpoint: "/com.coralogixapis.quota.v1.PoliciesService/DeletePolicy".into(),
215 feature_group: TCO_FEATURE_GROUP_ID.into(),
216 })
217 })
218 }
219
220 pub async fn get(&self, id: String) -> Result<GetPolicyResponse> {
225 let request =
226 make_request_with_metadata(GetPolicyRequest { id: Some(id) }, &self.metadata_map);
227
228 self.service_client
229 .lock()
230 .await
231 .get_policy(request)
232 .await
233 .map(|r| r.into_inner())
234 .map_err(|status| {
235 SdkError::ApiError(SdkApiError {
236 status,
237 endpoint: "/com.coralogixapis.quota.v1.PoliciesService/GetPolicy".into(),
238 feature_group: TCO_FEATURE_GROUP_ID.into(),
239 })
240 })
241 }
242
243 pub async fn list(
249 &self,
250 source_type: SourceType,
251 enabled_only: bool,
252 ) -> Result<GetCompanyPoliciesResponse> {
253 let request = make_request_with_metadata(
254 GetCompanyPoliciesRequest {
255 enabled_only: Some(enabled_only),
256 source_type: Some(source_type.into()),
257 },
258 &self.metadata_map,
259 );
260
261 self.service_client
262 .lock()
263 .await
264 .get_company_policies(request)
265 .await
266 .map(|r| r.into_inner())
267 .map_err(|status| {
268 SdkError::ApiError(SdkApiError {
269 status,
270 endpoint: "/com.coralogixapis.quota.v1.PoliciesService/GetCompanyPolicies"
271 .into(),
272 feature_group: TCO_FEATURE_GROUP_ID.into(),
273 })
274 })
275 }
276}