egc 0.1.2

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use docopt::Docopt;
use libedgegrid::ccu::req::{self, PurgeArls, PurgeCPCodes};
use libedgegrid::ccu::resp::{self, CCUResponseType};
use std::fs::File;
use std::io::{BufRead, BufReader};

#[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.
    -a AF --arlfile=AF  Read arls from a file instead of the command line.
    -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_arlfile: String,
    flag_timeout: usize,
}

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

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

    if ccuargs.cmd_qlen {
        queue_length(&ccuargs, auths)
    } else if ccuargs.cmd_purge {
        purge(&ccuargs, auths)
    } else if ccuargs.cmd_status {
        status(&ccuargs, 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);

    let mut arls: Vec<String> = Vec::new();

    if args.flag_arlfile.is_empty() {
        arls.extend(args.arg_arlorcp.clone().into_iter());
    } else {
        match File::open(&args.flag_arlfile) {
            Ok(f) => {
                let br = BufReader::new(f);
                for line in br.lines() {
                    if let Ok(l) = line {
                        arls.push(l);
                    }
                }
            }
            Err(e) => ::exit(format!("{}", e), 1),
        }
    };

    if !args.flag_cpcode {
        let body = PurgeArls::new(arls);

        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(arls);

        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),
    }
}