rusoto_outposts/
generated.rs

1// =================================================================
2//
3//                           * WARNING *
4//
5//                    This file is generated!
6//
7//  Changes made to this file will be overwritten. If changes are
8//  required to the generated code, the service_crategen project
9//  must be updated to generate the changes.
10//
11// =================================================================
12
13use std::error::Error;
14use std::fmt;
15
16use async_trait::async_trait;
17use rusoto_core::credential::ProvideAwsCredentials;
18use rusoto_core::region;
19use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
20use rusoto_core::{Client, RusotoError};
21
22use rusoto_core::param::{Params, ServiceParams};
23use rusoto_core::proto;
24use rusoto_core::signature::SignedRequest;
25#[allow(unused_imports)]
26use serde::{Deserialize, Serialize};
27use serde_json;
28#[derive(Clone, Debug, Default, PartialEq, Serialize)]
29#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
30pub struct CreateOutpostInput {
31    #[serde(rename = "AvailabilityZone")]
32    #[serde(skip_serializing_if = "Option::is_none")]
33    pub availability_zone: Option<String>,
34    #[serde(rename = "AvailabilityZoneId")]
35    #[serde(skip_serializing_if = "Option::is_none")]
36    pub availability_zone_id: Option<String>,
37    #[serde(rename = "Description")]
38    #[serde(skip_serializing_if = "Option::is_none")]
39    pub description: Option<String>,
40    #[serde(rename = "Name")]
41    #[serde(skip_serializing_if = "Option::is_none")]
42    pub name: Option<String>,
43    #[serde(rename = "SiteId")]
44    pub site_id: String,
45}
46
47#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
48#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
49pub struct CreateOutpostOutput {
50    #[serde(rename = "Outpost")]
51    #[serde(skip_serializing_if = "Option::is_none")]
52    pub outpost: Option<Outpost>,
53}
54
55#[derive(Clone, Debug, Default, PartialEq, Serialize)]
56#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
57pub struct DeleteOutpostInput {
58    #[serde(rename = "OutpostId")]
59    pub outpost_id: String,
60}
61
62#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
63#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
64pub struct DeleteOutpostOutput {}
65
66#[derive(Clone, Debug, Default, PartialEq, Serialize)]
67#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
68pub struct DeleteSiteInput {
69    #[serde(rename = "SiteId")]
70    pub site_id: String,
71}
72
73#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
74#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
75pub struct DeleteSiteOutput {}
76
77#[derive(Clone, Debug, Default, PartialEq, Serialize)]
78#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
79pub struct GetOutpostInput {
80    #[serde(rename = "OutpostId")]
81    pub outpost_id: String,
82}
83
84#[derive(Clone, Debug, Default, PartialEq, Serialize)]
85#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
86pub struct GetOutpostInstanceTypesInput {
87    #[serde(rename = "MaxResults")]
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub max_results: Option<i64>,
90    #[serde(rename = "NextToken")]
91    #[serde(skip_serializing_if = "Option::is_none")]
92    pub next_token: Option<String>,
93    #[serde(rename = "OutpostId")]
94    pub outpost_id: String,
95}
96
97#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
98#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
99pub struct GetOutpostInstanceTypesOutput {
100    #[serde(rename = "InstanceTypes")]
101    #[serde(skip_serializing_if = "Option::is_none")]
102    pub instance_types: Option<Vec<InstanceTypeItem>>,
103    #[serde(rename = "NextToken")]
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub next_token: Option<String>,
106    #[serde(rename = "OutpostArn")]
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub outpost_arn: Option<String>,
109    #[serde(rename = "OutpostId")]
110    #[serde(skip_serializing_if = "Option::is_none")]
111    pub outpost_id: Option<String>,
112}
113
114#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
115#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
116pub struct GetOutpostOutput {
117    #[serde(rename = "Outpost")]
118    #[serde(skip_serializing_if = "Option::is_none")]
119    pub outpost: Option<Outpost>,
120}
121
122/// <p>Information about an instance type.</p>
123#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
124#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
125pub struct InstanceTypeItem {
126    #[serde(rename = "InstanceType")]
127    #[serde(skip_serializing_if = "Option::is_none")]
128    pub instance_type: Option<String>,
129}
130
131#[derive(Clone, Debug, Default, PartialEq, Serialize)]
132#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
133pub struct ListOutpostsInput {
134    #[serde(rename = "MaxResults")]
135    #[serde(skip_serializing_if = "Option::is_none")]
136    pub max_results: Option<i64>,
137    #[serde(rename = "NextToken")]
138    #[serde(skip_serializing_if = "Option::is_none")]
139    pub next_token: Option<String>,
140}
141
142#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
143#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
144pub struct ListOutpostsOutput {
145    #[serde(rename = "NextToken")]
146    #[serde(skip_serializing_if = "Option::is_none")]
147    pub next_token: Option<String>,
148    #[serde(rename = "Outposts")]
149    #[serde(skip_serializing_if = "Option::is_none")]
150    pub outposts: Option<Vec<Outpost>>,
151}
152
153#[derive(Clone, Debug, Default, PartialEq, Serialize)]
154#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
155pub struct ListSitesInput {
156    #[serde(rename = "MaxResults")]
157    #[serde(skip_serializing_if = "Option::is_none")]
158    pub max_results: Option<i64>,
159    #[serde(rename = "NextToken")]
160    #[serde(skip_serializing_if = "Option::is_none")]
161    pub next_token: Option<String>,
162}
163
164#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
165#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
166pub struct ListSitesOutput {
167    #[serde(rename = "NextToken")]
168    #[serde(skip_serializing_if = "Option::is_none")]
169    pub next_token: Option<String>,
170    #[serde(rename = "Sites")]
171    #[serde(skip_serializing_if = "Option::is_none")]
172    pub sites: Option<Vec<Site>>,
173}
174
175/// <p>Information about an Outpost.</p>
176#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
177#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
178pub struct Outpost {
179    #[serde(rename = "AvailabilityZone")]
180    #[serde(skip_serializing_if = "Option::is_none")]
181    pub availability_zone: Option<String>,
182    #[serde(rename = "AvailabilityZoneId")]
183    #[serde(skip_serializing_if = "Option::is_none")]
184    pub availability_zone_id: Option<String>,
185    #[serde(rename = "Description")]
186    #[serde(skip_serializing_if = "Option::is_none")]
187    pub description: Option<String>,
188    #[serde(rename = "LifeCycleStatus")]
189    #[serde(skip_serializing_if = "Option::is_none")]
190    pub life_cycle_status: Option<String>,
191    #[serde(rename = "Name")]
192    #[serde(skip_serializing_if = "Option::is_none")]
193    pub name: Option<String>,
194    #[serde(rename = "OutpostArn")]
195    #[serde(skip_serializing_if = "Option::is_none")]
196    pub outpost_arn: Option<String>,
197    #[serde(rename = "OutpostId")]
198    #[serde(skip_serializing_if = "Option::is_none")]
199    pub outpost_id: Option<String>,
200    #[serde(rename = "OwnerId")]
201    #[serde(skip_serializing_if = "Option::is_none")]
202    pub owner_id: Option<String>,
203    #[serde(rename = "SiteId")]
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub site_id: Option<String>,
206}
207
208/// <p>Information about a site.</p>
209#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
210#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
211pub struct Site {
212    #[serde(rename = "AccountId")]
213    #[serde(skip_serializing_if = "Option::is_none")]
214    pub account_id: Option<String>,
215    #[serde(rename = "Description")]
216    #[serde(skip_serializing_if = "Option::is_none")]
217    pub description: Option<String>,
218    #[serde(rename = "Name")]
219    #[serde(skip_serializing_if = "Option::is_none")]
220    pub name: Option<String>,
221    #[serde(rename = "SiteId")]
222    #[serde(skip_serializing_if = "Option::is_none")]
223    pub site_id: Option<String>,
224}
225
226/// Errors returned by CreateOutpost
227#[derive(Debug, PartialEq)]
228pub enum CreateOutpostError {
229    /// <p>You do not have permission to perform this operation.</p>
230    AccessDenied(String),
231    /// <p>An internal error has occurred.</p>
232    InternalServer(String),
233    /// <p>The specified request is not valid.</p>
234    NotFound(String),
235    /// <p>You have exceeded a service quota.</p>
236    ServiceQuotaExceeded(String),
237}
238
239impl CreateOutpostError {
240    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateOutpostError> {
241        if let Some(err) = proto::json::Error::parse_rest(&res) {
242            match err.typ.as_str() {
243                "AccessDeniedException" => {
244                    return RusotoError::Service(CreateOutpostError::AccessDenied(err.msg))
245                }
246                "InternalServerException" => {
247                    return RusotoError::Service(CreateOutpostError::InternalServer(err.msg))
248                }
249                "NotFoundException" => {
250                    return RusotoError::Service(CreateOutpostError::NotFound(err.msg))
251                }
252                "ServiceQuotaExceededException" => {
253                    return RusotoError::Service(CreateOutpostError::ServiceQuotaExceeded(err.msg))
254                }
255                "ValidationException" => return RusotoError::Validation(err.msg),
256                _ => {}
257            }
258        }
259        RusotoError::Unknown(res)
260    }
261}
262impl fmt::Display for CreateOutpostError {
263    #[allow(unused_variables)]
264    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
265        match *self {
266            CreateOutpostError::AccessDenied(ref cause) => write!(f, "{}", cause),
267            CreateOutpostError::InternalServer(ref cause) => write!(f, "{}", cause),
268            CreateOutpostError::NotFound(ref cause) => write!(f, "{}", cause),
269            CreateOutpostError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
270        }
271    }
272}
273impl Error for CreateOutpostError {}
274/// Errors returned by DeleteOutpost
275#[derive(Debug, PartialEq)]
276pub enum DeleteOutpostError {
277    /// <p>You do not have permission to perform this operation.</p>
278    AccessDenied(String),
279    /// <p>An internal error has occurred.</p>
280    InternalServer(String),
281    /// <p>The specified request is not valid.</p>
282    NotFound(String),
283}
284
285impl DeleteOutpostError {
286    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteOutpostError> {
287        if let Some(err) = proto::json::Error::parse_rest(&res) {
288            match err.typ.as_str() {
289                "AccessDeniedException" => {
290                    return RusotoError::Service(DeleteOutpostError::AccessDenied(err.msg))
291                }
292                "InternalServerException" => {
293                    return RusotoError::Service(DeleteOutpostError::InternalServer(err.msg))
294                }
295                "NotFoundException" => {
296                    return RusotoError::Service(DeleteOutpostError::NotFound(err.msg))
297                }
298                "ValidationException" => return RusotoError::Validation(err.msg),
299                _ => {}
300            }
301        }
302        RusotoError::Unknown(res)
303    }
304}
305impl fmt::Display for DeleteOutpostError {
306    #[allow(unused_variables)]
307    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
308        match *self {
309            DeleteOutpostError::AccessDenied(ref cause) => write!(f, "{}", cause),
310            DeleteOutpostError::InternalServer(ref cause) => write!(f, "{}", cause),
311            DeleteOutpostError::NotFound(ref cause) => write!(f, "{}", cause),
312        }
313    }
314}
315impl Error for DeleteOutpostError {}
316/// Errors returned by DeleteSite
317#[derive(Debug, PartialEq)]
318pub enum DeleteSiteError {
319    /// <p>You do not have permission to perform this operation.</p>
320    AccessDenied(String),
321    /// <p>An internal error has occurred.</p>
322    InternalServer(String),
323    /// <p>The specified request is not valid.</p>
324    NotFound(String),
325}
326
327impl DeleteSiteError {
328    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSiteError> {
329        if let Some(err) = proto::json::Error::parse_rest(&res) {
330            match err.typ.as_str() {
331                "AccessDeniedException" => {
332                    return RusotoError::Service(DeleteSiteError::AccessDenied(err.msg))
333                }
334                "InternalServerException" => {
335                    return RusotoError::Service(DeleteSiteError::InternalServer(err.msg))
336                }
337                "NotFoundException" => {
338                    return RusotoError::Service(DeleteSiteError::NotFound(err.msg))
339                }
340                "ValidationException" => return RusotoError::Validation(err.msg),
341                _ => {}
342            }
343        }
344        RusotoError::Unknown(res)
345    }
346}
347impl fmt::Display for DeleteSiteError {
348    #[allow(unused_variables)]
349    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
350        match *self {
351            DeleteSiteError::AccessDenied(ref cause) => write!(f, "{}", cause),
352            DeleteSiteError::InternalServer(ref cause) => write!(f, "{}", cause),
353            DeleteSiteError::NotFound(ref cause) => write!(f, "{}", cause),
354        }
355    }
356}
357impl Error for DeleteSiteError {}
358/// Errors returned by GetOutpost
359#[derive(Debug, PartialEq)]
360pub enum GetOutpostError {
361    /// <p>You do not have permission to perform this operation.</p>
362    AccessDenied(String),
363    /// <p>An internal error has occurred.</p>
364    InternalServer(String),
365    /// <p>The specified request is not valid.</p>
366    NotFound(String),
367}
368
369impl GetOutpostError {
370    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetOutpostError> {
371        if let Some(err) = proto::json::Error::parse_rest(&res) {
372            match err.typ.as_str() {
373                "AccessDeniedException" => {
374                    return RusotoError::Service(GetOutpostError::AccessDenied(err.msg))
375                }
376                "InternalServerException" => {
377                    return RusotoError::Service(GetOutpostError::InternalServer(err.msg))
378                }
379                "NotFoundException" => {
380                    return RusotoError::Service(GetOutpostError::NotFound(err.msg))
381                }
382                "ValidationException" => return RusotoError::Validation(err.msg),
383                _ => {}
384            }
385        }
386        RusotoError::Unknown(res)
387    }
388}
389impl fmt::Display for GetOutpostError {
390    #[allow(unused_variables)]
391    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
392        match *self {
393            GetOutpostError::AccessDenied(ref cause) => write!(f, "{}", cause),
394            GetOutpostError::InternalServer(ref cause) => write!(f, "{}", cause),
395            GetOutpostError::NotFound(ref cause) => write!(f, "{}", cause),
396        }
397    }
398}
399impl Error for GetOutpostError {}
400/// Errors returned by GetOutpostInstanceTypes
401#[derive(Debug, PartialEq)]
402pub enum GetOutpostInstanceTypesError {
403    /// <p>You do not have permission to perform this operation.</p>
404    AccessDenied(String),
405    /// <p>An internal error has occurred.</p>
406    InternalServer(String),
407    /// <p>The specified request is not valid.</p>
408    NotFound(String),
409}
410
411impl GetOutpostInstanceTypesError {
412    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetOutpostInstanceTypesError> {
413        if let Some(err) = proto::json::Error::parse_rest(&res) {
414            match err.typ.as_str() {
415                "AccessDeniedException" => {
416                    return RusotoError::Service(GetOutpostInstanceTypesError::AccessDenied(
417                        err.msg,
418                    ))
419                }
420                "InternalServerException" => {
421                    return RusotoError::Service(GetOutpostInstanceTypesError::InternalServer(
422                        err.msg,
423                    ))
424                }
425                "NotFoundException" => {
426                    return RusotoError::Service(GetOutpostInstanceTypesError::NotFound(err.msg))
427                }
428                "ValidationException" => return RusotoError::Validation(err.msg),
429                _ => {}
430            }
431        }
432        RusotoError::Unknown(res)
433    }
434}
435impl fmt::Display for GetOutpostInstanceTypesError {
436    #[allow(unused_variables)]
437    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
438        match *self {
439            GetOutpostInstanceTypesError::AccessDenied(ref cause) => write!(f, "{}", cause),
440            GetOutpostInstanceTypesError::InternalServer(ref cause) => write!(f, "{}", cause),
441            GetOutpostInstanceTypesError::NotFound(ref cause) => write!(f, "{}", cause),
442        }
443    }
444}
445impl Error for GetOutpostInstanceTypesError {}
446/// Errors returned by ListOutposts
447#[derive(Debug, PartialEq)]
448pub enum ListOutpostsError {
449    /// <p>You do not have permission to perform this operation.</p>
450    AccessDenied(String),
451    /// <p>An internal error has occurred.</p>
452    InternalServer(String),
453}
454
455impl ListOutpostsError {
456    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListOutpostsError> {
457        if let Some(err) = proto::json::Error::parse_rest(&res) {
458            match err.typ.as_str() {
459                "AccessDeniedException" => {
460                    return RusotoError::Service(ListOutpostsError::AccessDenied(err.msg))
461                }
462                "InternalServerException" => {
463                    return RusotoError::Service(ListOutpostsError::InternalServer(err.msg))
464                }
465                "ValidationException" => return RusotoError::Validation(err.msg),
466                _ => {}
467            }
468        }
469        RusotoError::Unknown(res)
470    }
471}
472impl fmt::Display for ListOutpostsError {
473    #[allow(unused_variables)]
474    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
475        match *self {
476            ListOutpostsError::AccessDenied(ref cause) => write!(f, "{}", cause),
477            ListOutpostsError::InternalServer(ref cause) => write!(f, "{}", cause),
478        }
479    }
480}
481impl Error for ListOutpostsError {}
482/// Errors returned by ListSites
483#[derive(Debug, PartialEq)]
484pub enum ListSitesError {
485    /// <p>You do not have permission to perform this operation.</p>
486    AccessDenied(String),
487    /// <p>An internal error has occurred.</p>
488    InternalServer(String),
489}
490
491impl ListSitesError {
492    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSitesError> {
493        if let Some(err) = proto::json::Error::parse_rest(&res) {
494            match err.typ.as_str() {
495                "AccessDeniedException" => {
496                    return RusotoError::Service(ListSitesError::AccessDenied(err.msg))
497                }
498                "InternalServerException" => {
499                    return RusotoError::Service(ListSitesError::InternalServer(err.msg))
500                }
501                "ValidationException" => return RusotoError::Validation(err.msg),
502                _ => {}
503            }
504        }
505        RusotoError::Unknown(res)
506    }
507}
508impl fmt::Display for ListSitesError {
509    #[allow(unused_variables)]
510    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
511        match *self {
512            ListSitesError::AccessDenied(ref cause) => write!(f, "{}", cause),
513            ListSitesError::InternalServer(ref cause) => write!(f, "{}", cause),
514        }
515    }
516}
517impl Error for ListSitesError {}
518/// Trait representing the capabilities of the Outposts API. Outposts clients implement this trait.
519#[async_trait]
520pub trait Outposts {
521    /// <p>Creates an Outpost.</p>
522    async fn create_outpost(
523        &self,
524        input: CreateOutpostInput,
525    ) -> Result<CreateOutpostOutput, RusotoError<CreateOutpostError>>;
526
527    /// <p>Deletes the Outpost.</p>
528    async fn delete_outpost(
529        &self,
530        input: DeleteOutpostInput,
531    ) -> Result<DeleteOutpostOutput, RusotoError<DeleteOutpostError>>;
532
533    /// <p>Deletes the site.</p>
534    async fn delete_site(
535        &self,
536        input: DeleteSiteInput,
537    ) -> Result<DeleteSiteOutput, RusotoError<DeleteSiteError>>;
538
539    /// <p>Gets information about the specified Outpost.</p>
540    async fn get_outpost(
541        &self,
542        input: GetOutpostInput,
543    ) -> Result<GetOutpostOutput, RusotoError<GetOutpostError>>;
544
545    /// <p>Lists the instance types for the specified Outpost.</p>
546    async fn get_outpost_instance_types(
547        &self,
548        input: GetOutpostInstanceTypesInput,
549    ) -> Result<GetOutpostInstanceTypesOutput, RusotoError<GetOutpostInstanceTypesError>>;
550
551    /// <p>List the Outposts for your AWS account.</p>
552    async fn list_outposts(
553        &self,
554        input: ListOutpostsInput,
555    ) -> Result<ListOutpostsOutput, RusotoError<ListOutpostsError>>;
556
557    /// <p>Lists the sites for the specified AWS account.</p>
558    async fn list_sites(
559        &self,
560        input: ListSitesInput,
561    ) -> Result<ListSitesOutput, RusotoError<ListSitesError>>;
562}
563/// A client for the Outposts API.
564#[derive(Clone)]
565pub struct OutpostsClient {
566    client: Client,
567    region: region::Region,
568}
569
570impl OutpostsClient {
571    /// Creates a client backed by the default tokio event loop.
572    ///
573    /// The client will use the default credentials provider and tls client.
574    pub fn new(region: region::Region) -> OutpostsClient {
575        OutpostsClient {
576            client: Client::shared(),
577            region,
578        }
579    }
580
581    pub fn new_with<P, D>(
582        request_dispatcher: D,
583        credentials_provider: P,
584        region: region::Region,
585    ) -> OutpostsClient
586    where
587        P: ProvideAwsCredentials + Send + Sync + 'static,
588        D: DispatchSignedRequest + Send + Sync + 'static,
589    {
590        OutpostsClient {
591            client: Client::new_with(credentials_provider, request_dispatcher),
592            region,
593        }
594    }
595
596    pub fn new_with_client(client: Client, region: region::Region) -> OutpostsClient {
597        OutpostsClient { client, region }
598    }
599}
600
601#[async_trait]
602impl Outposts for OutpostsClient {
603    /// <p>Creates an Outpost.</p>
604    #[allow(unused_mut)]
605    async fn create_outpost(
606        &self,
607        input: CreateOutpostInput,
608    ) -> Result<CreateOutpostOutput, RusotoError<CreateOutpostError>> {
609        let request_uri = "/outposts";
610
611        let mut request = SignedRequest::new("POST", "outposts", &self.region, &request_uri);
612        request.set_content_type("application/x-amz-json-1.1".to_owned());
613
614        let encoded = Some(serde_json::to_vec(&input).unwrap());
615        request.set_payload(encoded);
616
617        let mut response = self
618            .client
619            .sign_and_dispatch(request)
620            .await
621            .map_err(RusotoError::from)?;
622        if response.status.is_success() {
623            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
624            let result = proto::json::ResponsePayload::new(&response)
625                .deserialize::<CreateOutpostOutput, _>()?;
626
627            Ok(result)
628        } else {
629            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
630            Err(CreateOutpostError::from_response(response))
631        }
632    }
633
634    /// <p>Deletes the Outpost.</p>
635    #[allow(unused_mut)]
636    async fn delete_outpost(
637        &self,
638        input: DeleteOutpostInput,
639    ) -> Result<DeleteOutpostOutput, RusotoError<DeleteOutpostError>> {
640        let request_uri = format!("/outposts/{outpost_id}", outpost_id = input.outpost_id);
641
642        let mut request = SignedRequest::new("DELETE", "outposts", &self.region, &request_uri);
643        request.set_content_type("application/x-amz-json-1.1".to_owned());
644
645        let mut response = self
646            .client
647            .sign_and_dispatch(request)
648            .await
649            .map_err(RusotoError::from)?;
650        if response.status.is_success() {
651            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
652            let result = proto::json::ResponsePayload::new(&response)
653                .deserialize::<DeleteOutpostOutput, _>()?;
654
655            Ok(result)
656        } else {
657            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
658            Err(DeleteOutpostError::from_response(response))
659        }
660    }
661
662    /// <p>Deletes the site.</p>
663    #[allow(unused_mut)]
664    async fn delete_site(
665        &self,
666        input: DeleteSiteInput,
667    ) -> Result<DeleteSiteOutput, RusotoError<DeleteSiteError>> {
668        let request_uri = format!("/sites/{site_id}", site_id = input.site_id);
669
670        let mut request = SignedRequest::new("DELETE", "outposts", &self.region, &request_uri);
671        request.set_content_type("application/x-amz-json-1.1".to_owned());
672
673        let mut response = self
674            .client
675            .sign_and_dispatch(request)
676            .await
677            .map_err(RusotoError::from)?;
678        if response.status.is_success() {
679            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
680            let result = proto::json::ResponsePayload::new(&response)
681                .deserialize::<DeleteSiteOutput, _>()?;
682
683            Ok(result)
684        } else {
685            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
686            Err(DeleteSiteError::from_response(response))
687        }
688    }
689
690    /// <p>Gets information about the specified Outpost.</p>
691    #[allow(unused_mut)]
692    async fn get_outpost(
693        &self,
694        input: GetOutpostInput,
695    ) -> Result<GetOutpostOutput, RusotoError<GetOutpostError>> {
696        let request_uri = format!("/outposts/{outpost_id}", outpost_id = input.outpost_id);
697
698        let mut request = SignedRequest::new("GET", "outposts", &self.region, &request_uri);
699        request.set_content_type("application/x-amz-json-1.1".to_owned());
700
701        let mut response = self
702            .client
703            .sign_and_dispatch(request)
704            .await
705            .map_err(RusotoError::from)?;
706        if response.status.is_success() {
707            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
708            let result = proto::json::ResponsePayload::new(&response)
709                .deserialize::<GetOutpostOutput, _>()?;
710
711            Ok(result)
712        } else {
713            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
714            Err(GetOutpostError::from_response(response))
715        }
716    }
717
718    /// <p>Lists the instance types for the specified Outpost.</p>
719    #[allow(unused_mut)]
720    async fn get_outpost_instance_types(
721        &self,
722        input: GetOutpostInstanceTypesInput,
723    ) -> Result<GetOutpostInstanceTypesOutput, RusotoError<GetOutpostInstanceTypesError>> {
724        let request_uri = format!(
725            "/outposts/{outpost_id}/instanceTypes",
726            outpost_id = input.outpost_id
727        );
728
729        let mut request = SignedRequest::new("GET", "outposts", &self.region, &request_uri);
730        request.set_content_type("application/x-amz-json-1.1".to_owned());
731
732        let mut params = Params::new();
733        if let Some(ref x) = input.max_results {
734            params.put("MaxResults", x);
735        }
736        if let Some(ref x) = input.next_token {
737            params.put("NextToken", x);
738        }
739        request.set_params(params);
740
741        let mut response = self
742            .client
743            .sign_and_dispatch(request)
744            .await
745            .map_err(RusotoError::from)?;
746        if response.status.is_success() {
747            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
748            let result = proto::json::ResponsePayload::new(&response)
749                .deserialize::<GetOutpostInstanceTypesOutput, _>()?;
750
751            Ok(result)
752        } else {
753            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
754            Err(GetOutpostInstanceTypesError::from_response(response))
755        }
756    }
757
758    /// <p>List the Outposts for your AWS account.</p>
759    #[allow(unused_mut)]
760    async fn list_outposts(
761        &self,
762        input: ListOutpostsInput,
763    ) -> Result<ListOutpostsOutput, RusotoError<ListOutpostsError>> {
764        let request_uri = "/outposts";
765
766        let mut request = SignedRequest::new("GET", "outposts", &self.region, &request_uri);
767        request.set_content_type("application/x-amz-json-1.1".to_owned());
768
769        let mut params = Params::new();
770        if let Some(ref x) = input.max_results {
771            params.put("MaxResults", x);
772        }
773        if let Some(ref x) = input.next_token {
774            params.put("NextToken", x);
775        }
776        request.set_params(params);
777
778        let mut response = self
779            .client
780            .sign_and_dispatch(request)
781            .await
782            .map_err(RusotoError::from)?;
783        if response.status.is_success() {
784            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
785            let result = proto::json::ResponsePayload::new(&response)
786                .deserialize::<ListOutpostsOutput, _>()?;
787
788            Ok(result)
789        } else {
790            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
791            Err(ListOutpostsError::from_response(response))
792        }
793    }
794
795    /// <p>Lists the sites for the specified AWS account.</p>
796    #[allow(unused_mut)]
797    async fn list_sites(
798        &self,
799        input: ListSitesInput,
800    ) -> Result<ListSitesOutput, RusotoError<ListSitesError>> {
801        let request_uri = "/sites";
802
803        let mut request = SignedRequest::new("GET", "outposts", &self.region, &request_uri);
804        request.set_content_type("application/x-amz-json-1.1".to_owned());
805
806        let mut params = Params::new();
807        if let Some(ref x) = input.max_results {
808            params.put("MaxResults", x);
809        }
810        if let Some(ref x) = input.next_token {
811            params.put("NextToken", x);
812        }
813        request.set_params(params);
814
815        let mut response = self
816            .client
817            .sign_and_dispatch(request)
818            .await
819            .map_err(RusotoError::from)?;
820        if response.status.is_success() {
821            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
822            let result =
823                proto::json::ResponsePayload::new(&response).deserialize::<ListSitesOutput, _>()?;
824
825            Ok(result)
826        } else {
827            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
828            Err(ListSitesError::from_response(response))
829        }
830    }
831}
rusoto_outposts/generated.rs

rusoto_outposts/
generated.rs
