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
110
111

use libedgegrid::{auth, luna};
use std::collections::HashMap;
use std::default::Default;

pub fn copy_config(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    match luna::lds::copy_config(&egr,
                                 &args.arg_serviceid,
                                 &args.arg_objid,
                                 &args.arg_objtype,
                                 args.arg_pgid) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::new(), 0)
}

pub fn delete_config(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    match luna::lds::delete_config(&egr, &args.arg_serviceid) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::new(), 0)
}

pub fn get_config(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    match luna::lds::get_config(&egr, &args.arg_serviceid) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::new(), 0)
}

pub fn get_configs(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    match luna::lds::get_configs(&egr) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::new(), 0)
}

pub fn post_config(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    let ppcd = Default::default();

    match luna::lds::post_config(&egr, &args.arg_serviceid, &ppcd) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::from("Not yet implemented!"), 0)
}

pub fn put_config(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    let ppcd = Default::default();

    match luna::lds::put_config(&egr, &args.arg_serviceid, &ppcd) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::from("Not yet implemented!"), 0)
}

pub fn resume_config(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    match luna::lds::resume_config(&egr, &args.arg_serviceid) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::new(), 0)
}

pub fn suspend_config(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    match luna::lds::suspend_config(&egr, &args.arg_serviceid) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::new(), 0)
}

pub fn get_dict(args: &::Args, auths: &mut HashMap<String, auth::EdgeGridAuth>) -> ! {
    let egr = ::get_auth("luna", args, auths);

    let objtype = match args.arg_oobjtype {
        Some(ref s) => Some(s),
        None => None,
    };

    let ckv = match args.arg_ckv {
        Some(ref s) => Some(s),
        None => None,
    };

    match luna::lds::get_dict(&egr, &args.arg_dictname, objtype, args.arg_oobjid, ckv) {
        Ok(resp) => println!("{:?}", resp),
        Err(e) => ::exit(format!("{:?}", e), 1),
    }
    ::exit(String::new(), 0)
}