libedgegrid 0.1.0

This library implements an Authentication handler for the Akamai OPEN EdgeGrid Authentication scheme in Rust
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
121
122
123
124
125
126
127
128

use curl::http;
use serde_json;
use std::fmt;

use self::CCUResponseType::*;

pub enum CCUResponseType {
    Purge,
    PurgeStatus,
    QueueLength,
}

#[cfg(feature = "serde_macros")]
include!("resp.rs.in");

#[cfg(not(feature = "serde_macros"))]
include!(concat!(env!("OUT_DIR"), "/ccu/resp.rs"));

impl fmt::Display for CCUError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let detail = match self.detail {
            Some(ref s) => &s[..],
            None        => "",
        };
        write!(f, "{}", detail)
    }
}

fn parse_ccu_error(body: String) -> ::EdgeGridResult {
    debug!("{}", body);
    let ccue: CCUError = try!(serde_json::from_str(&body));
    debug!("{:?}", ccue);
    Err(::EdgeGridError{
        title: match ccue.title {
            Some(t) => t,
            None    => String::new(),
        },
        detail: match ccue.detail {
            Some(d) => d,
            None    => String::new(),
        },
    })
}

pub fn parse_purge(
    resp: http::Response
) -> ::EdgeGridResult  {
    let body_vec = Vec::from(resp.get_body());
    let body = try!(String::from_utf8(body_vec));
    ::response::check_code(
        resp,
        body,
        |b| {
            let pr: PurgeResponse = try!(serde_json::from_str(&b));
            debug!("{:?}", pr);
            Ok(format!("{}: {}", pr.detail, pr.purge_id))
        },
        parse_ccu_error
    )
}

pub fn parse_purge_status(
    resp: http::Response
) -> ::EdgeGridResult  {
    let body_vec = Vec::from(resp.get_body());
    let body = try!(String::from_utf8(body_vec));
    ::response::check_code(
        resp,
        body,
        |b| {
            let psr: PurgeStatusResponse = try!(serde_json::from_str(&b));
            debug!("{:?}", psr);
            let mut out = String::new();

            match psr.purge_status {
                Some(ps) => {
                    out.push_str(&format!("Status: {}", ps)[..]);
                },
                None     => {},
            }

            match psr.submission_time {
                Some(st) => {
                    out.push_str(&format!("\nSubmitted at {}", st)[..]);
                },
                None     => {},
            }

            match psr.completion_time {
                Some(ct) => {
                    out.push_str(&format!("\nCompleted at {}", ct)[..]);
                },
                None     => {},
            }

            Ok(out)
        },
        parse_ccu_error
    )
}

pub fn parse_queue_length(
    resp: http::Response
) -> ::EdgeGridResult  {
    let body_vec = Vec::from(resp.get_body());
    let body = try!(String::from_utf8(body_vec));
    ::response::check_code(
        resp,
        body,
        |b| {
            let qlen: QueueLengthResponse = try!(serde_json::from_str(&b));
            debug!("{:?}", qlen);
            Ok(format!("{:?}", qlen.queue_length))
        },
        parse_ccu_error
    )
}

pub fn parse(
    resp: http::Response,
    ccu_type: CCUResponseType
) -> ::EdgeGridResult {
    match ccu_type {
        Purge       => parse_purge(resp),
        PurgeStatus => parse_purge_status(resp),
        QueueLength => parse_queue_length(resp),
    }
}