scribec 0.1.0

A client library for Facebook Scribe Server.
Documentation 
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

use std::io;

use argh::FromArgs;

use scribec::fb303::Fb303Status;
use scribec::scribe::LogEntry;
use scribec::client::ScribeClient;

#[derive(FromArgs, PartialEq, Debug)]
#[argh(description = "scribe client commands")]
struct ClientArgs {
    #[argh(subcommand)]
    subcommand: ScribeSubCommandEnum,

    #[argh(
        option,
        short = 'H',
        default = "String::from(\"localhost\")",
        description = "default: localhost"
    )]
    host: String,

    #[argh(option, short = 'p', default = "1463", description = "default: 1463")]
    port: u32,
}

#[derive(FromArgs, PartialEq, Debug)]
#[argh(subcommand)]
enum ScribeSubCommandEnum {
    Cat(SubCommandCat),
    StdLogger(SubCommandStdLogger),
    Admin(SubCommandAdmin),
}

#[derive(FromArgs, PartialEq, Debug)]
#[argh(subcommand, name = "cat", description = "cat")]
struct SubCommandCat {
    #[argh(positional)]
    category: String,
}

#[derive(FromArgs, PartialEq, Debug)]
#[argh(subcommand, name = "std_logger", description = "std_logger")]
struct SubCommandStdLogger {
    #[argh(positional)]
    category: String,
}

#[derive(FromArgs, PartialEq, Debug)]
#[argh(subcommand, name = "admin", description = "admin")]
struct SubCommandAdmin {
    #[argh(positional)]
    command: String,
}

fn main() {
    let args: ClientArgs = argh::from_env();
    let mut client = ScribeClient::new(args.host, args.port);

    match args.subcommand {
        ScribeSubCommandEnum::Cat(cat) => {
            let mut buffer = String::new();
            io::stdin().read_line(&mut buffer).unwrap();
            let logs = vec![LogEntry {
                category: Some(cat.category.clone()),
                message: Some(buffer),
            }];
            client.log(logs).unwrap();
        }
        ScribeSubCommandEnum::StdLogger(std_logger) => loop {
            let mut buffer = String::new();
            io::stdin().read_line(&mut buffer).unwrap();
            let logs = vec![LogEntry {
                category: Some(std_logger.category.clone()),
                message: Some(buffer),
            }];
            client.log(logs).unwrap();
        },
        ScribeSubCommandEnum::Admin(admin) => match admin.command.as_str() {
            "alive" => {
                let res = client.alive_since().unwrap();
                println!("{}", res);
            }
            "status" => {
                let mut msg = String::new();
                let res = client.get_status().unwrap();
                match res {
                    Fb303Status::DEAD => msg.push_str("DEAD"),
                    Fb303Status::ALIVE => msg.push_str("ALIVE"),
                    Fb303Status::STARTING => msg.push_str("STARTING"),
                    Fb303Status::STOPPING => msg.push_str("STOPPING"),
                    Fb303Status::STOPPED => msg.push_str("STOPPED"),
                    Fb303Status::WARNING => msg.push_str("WARNING"),
                    _ => msg.push_str("UNKNOWN"),
                }
                let detail = client.get_status_details().unwrap();
                if detail.len() > 0 {
                    msg.push_str(" - ");
                    msg.push_str(&detail);
                }
                println!("{}", msg);
            }
            "counters" => {
                let res = client.get_counters().unwrap();
                for (k, v) in res {
                    println!("{}: {}", k, v);
                }
            }
            "name" => {
                let res = client.get_name().unwrap();
                println!("{}", res);
            }
            "version" => {
                let res = client.get_version().unwrap();
                println!("{}", res);
            }
            _ => {
                println!("unkown admin command");
            }
        },
    }
}