google_cloud_recommender_v1/client.rs
1// Copyright 2025 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14//
15// Code generated by sidekick. DO NOT EDIT.
16#![allow(rustdoc::redundant_explicit_links)]
17#![allow(rustdoc::broken_intra_doc_links)]
18
19/// Implements a client for the Recommender API.
20///
21/// # Example
22/// ```
23/// # use google_cloud_recommender_v1::client::Recommender;
24/// use google_cloud_gax::paginator::ItemPaginator as _;
25/// # async fn sample() -> Result<(), Box<dyn std::error::Error>> {
26/// let client = Recommender::builder().build().await?;
27/// let parent = "parent_value";
28/// let mut list = client.list_insights()
29/// .set_parent(parent)
30/// .by_item();
31/// while let Some(item) = list.next().await.transpose()? {
32/// println!("{:?}", item);
33/// }
34/// # Ok(()) }
35/// ```
36///
37/// # Service Description
38///
39/// Provides insights and recommendations for cloud customers for various
40/// categories like performance optimization, cost savings, reliability, feature
41/// discovery, etc. Insights and recommendations are generated automatically
42/// based on analysis of user resources, configuration and monitoring metrics.
43///
44/// # Configuration
45///
46/// To configure `Recommender` use the `with_*` methods in the type returned
47/// by [builder()][Recommender::builder]. The default configuration should
48/// work for most applications. Common configuration changes include
49///
50/// * [with_endpoint()]: by default this client uses the global default endpoint
51/// (`https://recommender.googleapis.com`). Applications using regional
52/// endpoints or running in restricted networks (e.g. a network configured
53// with [Private Google Access with VPC Service Controls]) may want to
54/// override this default.
55/// * [with_credentials()]: by default this client uses
56/// [Application Default Credentials]. Applications using custom
57/// authentication may need to override this default.
58///
59/// [with_endpoint()]: super::builder::recommender::ClientBuilder::with_endpoint
60/// [with_credentials()]: super::builder::recommender::ClientBuilder::with_credentials
61/// [Private Google Access with VPC Service Controls]: https://cloud.google.com/vpc-service-controls/docs/private-connectivity
62/// [Application Default Credentials]: https://cloud.google.com/docs/authentication#adc
63///
64/// # Pooling and Cloning
65///
66/// `Recommender` holds a connection pool internally, it is advised to
67/// create one and reuse it. You do not need to wrap `Recommender` in
68/// an [Rc](std::rc::Rc) or [Arc](std::sync::Arc) to reuse it, because it
69/// already uses an `Arc` internally.
70#[derive(Clone, Debug)]
71pub struct Recommender {
72 inner: std::sync::Arc<dyn super::stub::dynamic::Recommender>,
73}
74
75impl Recommender {
76 /// Returns a builder for [Recommender].
77 ///
78 /// ```
79 /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
80 /// # use google_cloud_recommender_v1::client::Recommender;
81 /// let client = Recommender::builder().build().await?;
82 /// # Ok(()) }
83 /// ```
84 pub fn builder() -> super::builder::recommender::ClientBuilder {
85 crate::new_client_builder(super::builder::recommender::client::Factory)
86 }
87
88 /// Creates a new client from the provided stub.
89 ///
90 /// The most common case for calling this function is in tests mocking the
91 /// client's behavior.
92 pub fn from_stub<T>(stub: T) -> Self
93 where
94 T: super::stub::Recommender + 'static,
95 {
96 Self {
97 inner: std::sync::Arc::new(stub),
98 }
99 }
100
101 pub(crate) async fn new(
102 config: gaxi::options::ClientConfig,
103 ) -> crate::ClientBuilderResult<Self> {
104 let inner = Self::build_inner(config).await?;
105 Ok(Self { inner })
106 }
107
108 async fn build_inner(
109 conf: gaxi::options::ClientConfig,
110 ) -> crate::ClientBuilderResult<std::sync::Arc<dyn super::stub::dynamic::Recommender>> {
111 if gaxi::options::tracing_enabled(&conf) {
112 return Ok(std::sync::Arc::new(Self::build_with_tracing(conf).await?));
113 }
114 Ok(std::sync::Arc::new(Self::build_transport(conf).await?))
115 }
116
117 async fn build_transport(
118 conf: gaxi::options::ClientConfig,
119 ) -> crate::ClientBuilderResult<impl super::stub::Recommender> {
120 super::transport::Recommender::new(conf).await
121 }
122
123 async fn build_with_tracing(
124 conf: gaxi::options::ClientConfig,
125 ) -> crate::ClientBuilderResult<impl super::stub::Recommender> {
126 Self::build_transport(conf)
127 .await
128 .map(super::tracing::Recommender::new)
129 }
130
131 /// Lists insights for the specified Cloud Resource. Requires the
132 /// recommender.*.list IAM permission for the specified insight type.
133 ///
134 /// # Example
135 /// ```
136 /// # use google_cloud_recommender_v1::client::Recommender;
137 /// use google_cloud_gax::paginator::ItemPaginator as _;
138 /// use google_cloud_recommender_v1::Result;
139 /// async fn sample(
140 /// client: &Recommender, parent: &str
141 /// ) -> Result<()> {
142 /// let mut list = client.list_insights()
143 /// .set_parent(parent)
144 /// .by_item();
145 /// while let Some(item) = list.next().await.transpose()? {
146 /// println!("{:?}", item);
147 /// }
148 /// Ok(())
149 /// }
150 /// ```
151 pub fn list_insights(&self) -> super::builder::recommender::ListInsights {
152 super::builder::recommender::ListInsights::new(self.inner.clone())
153 }
154
155 /// Gets the requested insight. Requires the recommender.*.get IAM permission
156 /// for the specified insight type.
157 ///
158 /// # Example
159 /// ```
160 /// # use google_cloud_recommender_v1::client::Recommender;
161 /// use google_cloud_recommender_v1::Result;
162 /// async fn sample(
163 /// client: &Recommender, name: &str
164 /// ) -> Result<()> {
165 /// let response = client.get_insight()
166 /// .set_name(name)
167 /// .send().await?;
168 /// println!("response {:?}", response);
169 /// Ok(())
170 /// }
171 /// ```
172 pub fn get_insight(&self) -> super::builder::recommender::GetInsight {
173 super::builder::recommender::GetInsight::new(self.inner.clone())
174 }
175
176 /// Marks the Insight State as Accepted. Users can use this method to
177 /// indicate to the Recommender API that they have applied some action based
178 /// on the insight. This stops the insight content from being updated.
179 ///
180 /// MarkInsightAccepted can be applied to insights in ACTIVE state. Requires
181 /// the recommender.*.update IAM permission for the specified insight.
182 ///
183 /// # Example
184 /// ```
185 /// # use google_cloud_recommender_v1::client::Recommender;
186 /// use google_cloud_recommender_v1::Result;
187 /// async fn sample(
188 /// client: &Recommender
189 /// ) -> Result<()> {
190 /// let response = client.mark_insight_accepted()
191 /// /* set fields */
192 /// .send().await?;
193 /// println!("response {:?}", response);
194 /// Ok(())
195 /// }
196 /// ```
197 pub fn mark_insight_accepted(&self) -> super::builder::recommender::MarkInsightAccepted {
198 super::builder::recommender::MarkInsightAccepted::new(self.inner.clone())
199 }
200
201 /// Lists recommendations for the specified Cloud Resource. Requires the
202 /// recommender.*.list IAM permission for the specified recommender.
203 ///
204 /// # Example
205 /// ```
206 /// # use google_cloud_recommender_v1::client::Recommender;
207 /// use google_cloud_gax::paginator::ItemPaginator as _;
208 /// use google_cloud_recommender_v1::Result;
209 /// async fn sample(
210 /// client: &Recommender, parent: &str
211 /// ) -> Result<()> {
212 /// let mut list = client.list_recommendations()
213 /// .set_parent(parent)
214 /// .by_item();
215 /// while let Some(item) = list.next().await.transpose()? {
216 /// println!("{:?}", item);
217 /// }
218 /// Ok(())
219 /// }
220 /// ```
221 pub fn list_recommendations(&self) -> super::builder::recommender::ListRecommendations {
222 super::builder::recommender::ListRecommendations::new(self.inner.clone())
223 }
224
225 /// Gets the requested recommendation. Requires the recommender.*.get
226 /// IAM permission for the specified recommender.
227 ///
228 /// # Example
229 /// ```
230 /// # use google_cloud_recommender_v1::client::Recommender;
231 /// use google_cloud_recommender_v1::Result;
232 /// async fn sample(
233 /// client: &Recommender, name: &str
234 /// ) -> Result<()> {
235 /// let response = client.get_recommendation()
236 /// .set_name(name)
237 /// .send().await?;
238 /// println!("response {:?}", response);
239 /// Ok(())
240 /// }
241 /// ```
242 pub fn get_recommendation(&self) -> super::builder::recommender::GetRecommendation {
243 super::builder::recommender::GetRecommendation::new(self.inner.clone())
244 }
245
246 /// Mark the Recommendation State as Dismissed. Users can use this method to
247 /// indicate to the Recommender API that an ACTIVE recommendation has to
248 /// be marked back as DISMISSED.
249 ///
250 /// MarkRecommendationDismissed can be applied to recommendations in ACTIVE
251 /// state.
252 ///
253 /// Requires the recommender.*.update IAM permission for the specified
254 /// recommender.
255 ///
256 /// # Example
257 /// ```
258 /// # use google_cloud_recommender_v1::client::Recommender;
259 /// use google_cloud_recommender_v1::Result;
260 /// async fn sample(
261 /// client: &Recommender
262 /// ) -> Result<()> {
263 /// let response = client.mark_recommendation_dismissed()
264 /// /* set fields */
265 /// .send().await?;
266 /// println!("response {:?}", response);
267 /// Ok(())
268 /// }
269 /// ```
270 pub fn mark_recommendation_dismissed(
271 &self,
272 ) -> super::builder::recommender::MarkRecommendationDismissed {
273 super::builder::recommender::MarkRecommendationDismissed::new(self.inner.clone())
274 }
275
276 /// Marks the Recommendation State as Claimed. Users can use this method to
277 /// indicate to the Recommender API that they are starting to apply the
278 /// recommendation themselves. This stops the recommendation content from being
279 /// updated. Associated insights are frozen and placed in the ACCEPTED state.
280 ///
281 /// MarkRecommendationClaimed can be applied to recommendations in CLAIMED,
282 /// SUCCEEDED, FAILED, or ACTIVE state.
283 ///
284 /// Requires the recommender.*.update IAM permission for the specified
285 /// recommender.
286 ///
287 /// # Example
288 /// ```
289 /// # use google_cloud_recommender_v1::client::Recommender;
290 /// use google_cloud_recommender_v1::Result;
291 /// async fn sample(
292 /// client: &Recommender
293 /// ) -> Result<()> {
294 /// let response = client.mark_recommendation_claimed()
295 /// /* set fields */
296 /// .send().await?;
297 /// println!("response {:?}", response);
298 /// Ok(())
299 /// }
300 /// ```
301 pub fn mark_recommendation_claimed(
302 &self,
303 ) -> super::builder::recommender::MarkRecommendationClaimed {
304 super::builder::recommender::MarkRecommendationClaimed::new(self.inner.clone())
305 }
306
307 /// Marks the Recommendation State as Succeeded. Users can use this method to
308 /// indicate to the Recommender API that they have applied the recommendation
309 /// themselves, and the operation was successful. This stops the recommendation
310 /// content from being updated. Associated insights are frozen and placed in
311 /// the ACCEPTED state.
312 ///
313 /// MarkRecommendationSucceeded can be applied to recommendations in ACTIVE,
314 /// CLAIMED, SUCCEEDED, or FAILED state.
315 ///
316 /// Requires the recommender.*.update IAM permission for the specified
317 /// recommender.
318 ///
319 /// # Example
320 /// ```
321 /// # use google_cloud_recommender_v1::client::Recommender;
322 /// use google_cloud_recommender_v1::Result;
323 /// async fn sample(
324 /// client: &Recommender
325 /// ) -> Result<()> {
326 /// let response = client.mark_recommendation_succeeded()
327 /// /* set fields */
328 /// .send().await?;
329 /// println!("response {:?}", response);
330 /// Ok(())
331 /// }
332 /// ```
333 pub fn mark_recommendation_succeeded(
334 &self,
335 ) -> super::builder::recommender::MarkRecommendationSucceeded {
336 super::builder::recommender::MarkRecommendationSucceeded::new(self.inner.clone())
337 }
338
339 /// Marks the Recommendation State as Failed. Users can use this method to
340 /// indicate to the Recommender API that they have applied the recommendation
341 /// themselves, and the operation failed. This stops the recommendation content
342 /// from being updated. Associated insights are frozen and placed in the
343 /// ACCEPTED state.
344 ///
345 /// MarkRecommendationFailed can be applied to recommendations in ACTIVE,
346 /// CLAIMED, SUCCEEDED, or FAILED state.
347 ///
348 /// Requires the recommender.*.update IAM permission for the specified
349 /// recommender.
350 ///
351 /// # Example
352 /// ```
353 /// # use google_cloud_recommender_v1::client::Recommender;
354 /// use google_cloud_recommender_v1::Result;
355 /// async fn sample(
356 /// client: &Recommender
357 /// ) -> Result<()> {
358 /// let response = client.mark_recommendation_failed()
359 /// /* set fields */
360 /// .send().await?;
361 /// println!("response {:?}", response);
362 /// Ok(())
363 /// }
364 /// ```
365 pub fn mark_recommendation_failed(
366 &self,
367 ) -> super::builder::recommender::MarkRecommendationFailed {
368 super::builder::recommender::MarkRecommendationFailed::new(self.inner.clone())
369 }
370
371 /// Gets the requested Recommender Config. There is only one instance of the
372 /// config for each Recommender.
373 ///
374 /// # Example
375 /// ```
376 /// # use google_cloud_recommender_v1::client::Recommender;
377 /// use google_cloud_recommender_v1::Result;
378 /// async fn sample(
379 /// client: &Recommender, name: &str
380 /// ) -> Result<()> {
381 /// let response = client.get_recommender_config()
382 /// .set_name(name)
383 /// .send().await?;
384 /// println!("response {:?}", response);
385 /// Ok(())
386 /// }
387 /// ```
388 pub fn get_recommender_config(&self) -> super::builder::recommender::GetRecommenderConfig {
389 super::builder::recommender::GetRecommenderConfig::new(self.inner.clone())
390 }
391
392 /// Updates a Recommender Config. This will create a new revision of the
393 /// config.
394 ///
395 /// # Example
396 /// ```
397 /// # use google_cloud_recommender_v1::client::Recommender;
398 /// # extern crate wkt as google_cloud_wkt;
399 /// use google_cloud_wkt::FieldMask;
400 /// use google_cloud_recommender_v1::model::RecommenderConfig;
401 /// use google_cloud_recommender_v1::Result;
402 /// async fn sample(
403 /// client: &Recommender, name: &str
404 /// ) -> Result<()> {
405 /// let response = client.update_recommender_config()
406 /// .set_recommender_config(
407 /// RecommenderConfig::new().set_name(name)/* set fields */
408 /// )
409 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
410 /// .send().await?;
411 /// println!("response {:?}", response);
412 /// Ok(())
413 /// }
414 /// ```
415 pub fn update_recommender_config(
416 &self,
417 ) -> super::builder::recommender::UpdateRecommenderConfig {
418 super::builder::recommender::UpdateRecommenderConfig::new(self.inner.clone())
419 }
420
421 /// Gets the requested InsightTypeConfig. There is only one instance of the
422 /// config for each InsightType.
423 ///
424 /// # Example
425 /// ```
426 /// # use google_cloud_recommender_v1::client::Recommender;
427 /// use google_cloud_recommender_v1::Result;
428 /// async fn sample(
429 /// client: &Recommender, name: &str
430 /// ) -> Result<()> {
431 /// let response = client.get_insight_type_config()
432 /// .set_name(name)
433 /// .send().await?;
434 /// println!("response {:?}", response);
435 /// Ok(())
436 /// }
437 /// ```
438 pub fn get_insight_type_config(&self) -> super::builder::recommender::GetInsightTypeConfig {
439 super::builder::recommender::GetInsightTypeConfig::new(self.inner.clone())
440 }
441
442 /// Updates an InsightTypeConfig change. This will create a new revision of the
443 /// config.
444 ///
445 /// # Example
446 /// ```
447 /// # use google_cloud_recommender_v1::client::Recommender;
448 /// # extern crate wkt as google_cloud_wkt;
449 /// use google_cloud_wkt::FieldMask;
450 /// use google_cloud_recommender_v1::model::InsightTypeConfig;
451 /// use google_cloud_recommender_v1::Result;
452 /// async fn sample(
453 /// client: &Recommender, name: &str
454 /// ) -> Result<()> {
455 /// let response = client.update_insight_type_config()
456 /// .set_insight_type_config(
457 /// InsightTypeConfig::new().set_name(name)/* set fields */
458 /// )
459 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
460 /// .send().await?;
461 /// println!("response {:?}", response);
462 /// Ok(())
463 /// }
464 /// ```
465 pub fn update_insight_type_config(
466 &self,
467 ) -> super::builder::recommender::UpdateInsightTypeConfig {
468 super::builder::recommender::UpdateInsightTypeConfig::new(self.inner.clone())
469 }
470}