egc 0.1.1

This library implements an Akamai OPEN EdgeGrid Client 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

use docopt::Docopt;
use libedgegrid::luna::alert::req::{self, AlertPostData};
use libedgegrid::luna::alert::resp::{self, AlertResponseType};

#[cfg_attr(rustfmt, rustfmt_skip)]
static USAGE: &'static str = "alert - Run the Akamai EdgeGrid Alert API

Usage:
    alert [options] -i <alertid>
    alert [options] (get|post) [<cpcode>...]

Options:
    -i --byid           Lookup the alert by id.
    -t MS --timeout=MS  Set the curl timeout for the request in milliseconds.

Examples:
    N/A";

#[derive(Debug, RustcDecodable)]
pub struct AlertArgs {
    arg_alertid: String,
    arg_cpcode: Option<Vec<String>>,
    cmd_get: bool,
    cmd_post: bool,
    flag_timeout: usize,
    flag_byid: bool,
}

pub fn usage<'a>() -> &'a str {
    USAGE
}

pub fn parse_args(args: Vec<String>, auths: &mut ::AuthsHashMap) -> ! {
    let argv = || args;
    let args: AlertArgs = Docopt::new(USAGE)
                              .and_then(|d| d.argv(argv().into_iter()).decode())
                              .unwrap_or_else(|e| e.exit());

    if args.flag_byid {
        get_by_id(&args, auths)
    } else if args.cmd_get {
        get(&args, auths)
    } else if args.cmd_post {
        post(&args, auths)
    } else {
        ::exit(String::from("Unknown command!"), 1);
    }
}

pub fn get_by_id(args: &AlertArgs, auths: &mut ::AuthsHashMap) -> ! {
    let egr = ::get_auth("luna", args.flag_timeout, auths);
    match req::get_by_id(&egr, &args.arg_alertid) {
        Ok(r) => {
            debug!("{:?}", r);
            match resp::parse(r, AlertResponseType::GetById) {
                Ok(o) => ::exit(o, 0),
                Err(e) => ::exit(format!("{}", e), 1),
            }
        }
        Err(e) => ::exit(format!("{}", e), 1),
    }
}

pub fn get(args: &AlertArgs, auths: &mut ::AuthsHashMap) -> ! {
    let egr = ::get_auth("luna", args.flag_timeout, auths);
    match req::get(&egr, &args.arg_cpcode) {
        Ok(r) => {
            debug!("{:?}", r);
            match resp::parse(r, AlertResponseType::Get) {
                Ok(o) => ::exit(o, 0),
                Err(e) => ::exit(format!("{}", e), 1),
            }
        }
        Err(e) => ::exit(format!("{}", e), 1),
    }
}

pub fn post(args: &AlertArgs, auths: &mut ::AuthsHashMap) -> ! {
    let egr = ::get_auth("luna", args.flag_timeout, auths);
    let body = AlertPostData::new(args.arg_cpcode.clone());
    match req::post(&egr, body) {
        Ok(r) => {
            debug!("{:?}", r);
            match resp::parse(r, AlertResponseType::Post) {
                Ok(o) => ::exit(o, 0),
                Err(e) => ::exit(format!("{}", e), 1),
            }
        }
        Err(e) => ::exit(format!("{}", e), 1),
    }
}