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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use docopt::Docopt;
use libedgegrid::ccu::req::{self, PurgeArls, PurgeCPCodes};
use libedgegrid::ccu::resp::{self, CCUResponseType};

#[cfg_attr(rustfmt, rustfmt_skip)]
static USAGE: &'static str = "ccu - Run the Akamai EdgeGrid Client Content Control Utility API

Usage:
    ccu [options] purge <queuename> <arlorcp>...
    ccu [options] qlen <queuename>
    ccu [options] status <purgeid>

Options:
    -c --cpcode         Enable a cpcode purge.
    -t MS --timeout=MS  Set the curl timeout for the request in milliseconds.

Examples:
    N/A";

#[derive(Debug, RustcDecodable)]
pub struct CCUArgs {
    arg_purgeid: String,
    arg_queuename: String,
    arg_arlorcp: Vec<String>,
    cmd_purge: bool,
    cmd_qlen: bool,
    cmd_status: bool,
    flag_cpcode: bool,
    flag_timeout: usize,
}

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

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

    if args.cmd_qlen {
        queue_length(&args, auths)
    } else if args.cmd_purge {
        purge(&args, auths)
    } else if args.cmd_status {
        status(&args, auths)
    } else {
        ::exit(String::from("Unknown command!"), 1);
    }
}

pub fn queue_length(args: &CCUArgs, auths: &mut ::AuthsHashMap) -> ! {
    let egr = ::get_auth("ccu", args.flag_timeout, auths);
    match req::queue_length(&egr, &args.arg_queuename[..]) {
        Ok(r) => {
            debug!("{:?}", r);
            match resp::parse(r, CCUResponseType::QueueLength) {
                Ok(o) => ::exit(o, 0),
                Err(e) => ::exit(format!("{}", e), 1),
            }
        }
        Err(e) => ::exit(format!("{}", e), 1),
    }
}

pub fn purge(args: &CCUArgs, auths: &mut ::AuthsHashMap) -> ! {
    let egr = ::get_auth("ccu", args.flag_timeout, auths);

    if !args.flag_cpcode {
        let body = PurgeArls::new(args.arg_arlorcp.clone());
        match req::purge_by_arl(&egr, &args.arg_queuename[..], body) {
            Ok(r) => {
                debug!("{:?}", r);
                match resp::parse(r, CCUResponseType::Purge) {
                    Ok(o) => ::exit(o, 0),
                    Err(e) => ::exit(format!("{}", e), 1),
                }
            }
            Err(e) => ::exit(format!("{}", e), 1),
        }
    } else {
        let body = PurgeCPCodes::new(args.arg_arlorcp.clone());
        match req::purge_by_cpcode(&egr, &args.arg_queuename[..], body) {
            Ok(r) => {
                debug!("{:?}", r);
                match resp::parse(r, CCUResponseType::Purge) {
                    Ok(o) => ::exit(o, 0),
                    Err(e) => ::exit(format!("{}", e), 1),
                }
            }
            Err(e) => ::exit(format!("{}", e), 1),
        }
    }
}

pub fn status(args: &CCUArgs, auths: &mut ::AuthsHashMap) -> ! {
    let egr = ::get_auth("ccu", args.flag_timeout, auths);
    match req::purge_status(&egr, &args.arg_purgeid[..]) {
        Ok(r) => {
            debug!("{:?}", r);
            match resp::parse(r, CCUResponseType::PurgeStatus) {
                Ok(o) => ::exit(o, 0),
                Err(e) => ::exit(format!("{}", e), 1),
            }
        }
        Err(e) => ::exit(format!("{}", e), 1),
    }
}