warheadhateus 0.2.1

AWS Authorization Header Generation (AWS Signature Version 4)
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

use chrono;
use sodium_sys;
use std::error::Error;
use std::fmt;
use std::string::FromUtf8Error;

#[derive(Debug)]
/// Authentication Error Types
pub enum AWSAuthError {
    /// Error thrown converting from UTF-8.
    FromUtf8Error(FromUtf8Error),
    /// Error thrown when running methods not valid for the current mode.
    ModeError,
    /// Error thrown during sodium operations.
    Nacl(sodium_sys::SSError),
    /// General error thrown during operation.
    Other(&'static str),
    /// Error thrown parsing a datetime.
    ParseError(chrono::ParseError),
}

impl Error for AWSAuthError {
    fn description(&self) -> &str {
        match *self {
            AWSAuthError::FromUtf8Error(ref e) => e.description(),
            AWSAuthError::ModeError => "ModeError",
            AWSAuthError::Nacl(_) => "Sodium SSError",
            AWSAuthError::Other(e) => e,
            AWSAuthError::ParseError(ref e) => e.description(),
        }
    }
}

impl fmt::Display for AWSAuthError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let display = match *self {
            AWSAuthError::FromUtf8Error(_) => "FromUtf8Error",
            AWSAuthError::ModeError => "ModeError",
            AWSAuthError::Nacl(_) => "SSError",
            AWSAuthError::Other(e) => e,
            AWSAuthError::ParseError(_) => "ParseError",
        };
        write!(f, "{}", display)
    }
}

impl From<sodium_sys::SSError> for AWSAuthError {
    fn from(e: sodium_sys::SSError) -> AWSAuthError {
        AWSAuthError::Nacl(e)
    }
}

impl From<FromUtf8Error> for AWSAuthError {
    fn from(e: FromUtf8Error) -> AWSAuthError {
        AWSAuthError::FromUtf8Error(e)
    }
}

impl From<chrono::format::ParseError> for AWSAuthError {
    fn from(e: chrono::format::ParseError) -> AWSAuthError {
        AWSAuthError::ParseError(e)
    }
}

#[derive(Debug,PartialEq)]
/// Thrown when a given region cannot be parsed.
pub struct ParseRegionError;

impl Error for ParseRegionError {
    fn description(&self) -> &str {
        "Unable to parse the given region"
    }
}

impl fmt::Display for ParseRegionError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ParseRegionError")
    }
}

#[derive(Debug,PartialEq)]
/// Thrown when a given service cannot be parsed.
pub struct ParseServiceError;

impl Error for ParseServiceError {
    fn description(&self) -> &str {
        "Unable to parse the given region"
    }
}

impl fmt::Display for ParseServiceError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ParseServiceError")
    }
}