aws-sdk-ec2 1.222.0

AWS SDK for Amazon Elastic Compute Cloud
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

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0
 */

use aws_smithy_types::error::metadata::{Builder as ErrorMetadataBuilder, ErrorMetadata};
use aws_smithy_xml::decode::{try_data, Document, ScopedDecoder, XmlDecodeError};

#[allow(unused)]
pub fn body_is_error(body: &[u8]) -> Result<bool, XmlDecodeError> {
    let mut doc = Document::try_from(body)?;
    let scoped = doc.root_element()?;
    Ok(scoped.start_el().matches("Response"))
}

pub fn parse_error_metadata(body: &[u8]) -> Result<ErrorMetadataBuilder, XmlDecodeError> {
    let mut doc = Document::try_from(body)?;
    let mut root = doc.root_element()?;
    let mut err_builder = ErrorMetadata::builder();
    while let Some(mut tag) = root.next_tag() {
        if tag.start_el().local() == "Errors" {
            while let Some(mut error_tag) = tag.next_tag() {
                if let "Error" = error_tag.start_el().local() {
                    while let Some(mut error_field) = error_tag.next_tag() {
                        match error_field.start_el().local() {
                            "Code" => {
                                err_builder = err_builder.code(try_data(&mut error_field)?);
                            }
                            "Message" => {
                                err_builder = err_builder.message(try_data(&mut error_field)?);
                            }
                            _ => {}
                        }
                    }
                }
            }
        }
    }
    Ok(err_builder)
}

#[allow(unused)]
pub fn error_scope<'a, 'b>(doc: &'a mut Document<'b>) -> Result<ScopedDecoder<'b, 'a>, XmlDecodeError> {
    let root = doc
        .next_start_element()
        .ok_or_else(|| XmlDecodeError::custom("no root found searching for an Error"))?;
    if !root.matches("Response") {
        return Err(XmlDecodeError::custom("expected Response as root"));
    }

    while let Some(el) = doc.next_start_element() {
        if el.matches("Errors") && el.depth() == 1 {
            while let Some(el) = doc.next_start_element() {
                if el.matches("Error") && el.depth() == 2 {
                    return Ok(doc.scoped_to(el));
                }
            }
        }
        // otherwise, ignore it
    }
    Err(XmlDecodeError::custom("no error found inside of response"))
}

#[cfg(test)]
mod test {
    use super::{body_is_error, parse_error_metadata};
    use crate::ec2_query_errors::error_scope;
    use aws_smithy_xml::decode::Document;

    #[test]
    fn parse_wrapped_error() {
        let xml = br#"
        <Response>
            <Errors>
                <Error>
                    <Code>InvalidGreeting</Code>
                    <Message>Hi</Message>
                    <AnotherSetting>setting</AnotherSetting>
                    <Ignore><This/></Ignore>
                </Error>
            </Errors>
            <RequestId>foo-id</RequestId>
        </Response>
        "#;
        assert!(body_is_error(xml).unwrap());
        let parsed = parse_error_metadata(xml).expect("valid xml").build();
        assert_eq!(parsed.message(), Some("Hi"));
        assert_eq!(parsed.code(), Some("InvalidGreeting"));
    }

    #[test]
    fn test_error_scope() {
        let xml: &[u8] = br#"
        <Response>
            <RequestId>foo-id</RequestId>
            <MorePreamble>foo-id</RequestId>
            <Sneaky><Error>These are not the errors you are looking for</Error></Sneaky>
            <Errors>
                <Sneaky><Error>These are not the errors you are looking for</Error></Sneaky>
                <Error>
                    <Code>InvalidGreeting</Code>
                    <Message>Hi</Message>
                    <AnotherSetting>setting</AnotherSetting>
                    <Ignore><This/></Ignore>
                </Error>
            </Errors>
            <RequestId>foo-id</RequestId>
        </Response>
        "#;
        let mut doc = Document::try_from(xml).expect("valid");
        let mut error = error_scope(&mut doc).expect("contains error");
        let mut keys = vec![];
        while let Some(tag) = error.next_tag() {
            keys.push(tag.start_el().local().to_owned());
            // read this the full contents of this element
        }
        assert_eq!(keys, vec!["Code", "Message", "AnotherSetting", "Ignore"])
    }
}