aboutsummaryrefslogtreecommitdiffstats
path: root/src/main.rs
blob: 98bd5e5355ab7c10f5eca6670471181e6187089f (plain)
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
extern crate getopts;
#[macro_use]
extern crate rouille;

extern crate kipper;

use std::env;
use std::io::Read;

use getopts::Options;

use kipper::jenkins;
use kipper::pull_request::CommitRef;

const DEFAULT_PORT: u16 = 8000;

fn print_usage(opts: Options) {
    let brief = "Usage: kipper --jenkins-url 'https://jenkins.example.com' --jenkins-user-id username --jenkins-token a72a57d448694703b2c3fd19e666ecc5 --github-token 1dc41fad0516460b870014b25b11847d";
    print!("{}", opts.usage(&brief));
}

fn internal_server_error() -> rouille::Response {
    rouille::Response::text("500 Internal Server Error")
        .with_status_code(500)
}

fn main() {
    let args: Vec<String> = env::args().collect();

    let mut opts = Options::new();
    opts.optopt("", "jenkins-url", "Jenkins URL (required)", "https://jenkins.example.com");
    opts.optopt("", "jenkins-user-id", "Jenkins user ID (required)", "USER_ID");
    opts.optopt("", "jenkins-token", "Jenkins API token (required)", "TOKEN");
    opts.optopt(
        "",
        "github-token",
        "GitHub API token with \"repo:status\" permission (required)",
        "TOKEN"
    );
    opts.optopt("p", "port", "set port number", "PORT");
    opts.optflag("h", "help", "print this help menu");

    let opt_matches = match opts.parse(&args[1..]) {
        Ok(m) => m,
        Err(e) => panic!(e.to_string()),
    };

    if opt_matches.opt_present("h") {
        print_usage(opts);
        return;
    }

    let jenkins_url = match opt_matches.opt_str("jenkins-url") {
        Some(url) => url,
        None => {
            print_usage(opts);
            return;
        },
    };

    let jenkins_user_id = match opt_matches.opt_str("jenkins-user-id") {
        Some(user_id) => user_id,
        None => {
            print_usage(opts);
            return;
        },
    };

    let jenkins_token = match opt_matches.opt_str("jenkins-token") {
        Some(token) => token,
        None => {
            print_usage(opts);
            return;
        },
    };

    let github_token = match opt_matches.opt_str("github-token") {
        Some(token) => token,
        None => {
            print_usage(opts);
            return;
        },
    };

    let port = match opt_matches.opt_str("p") {
        Some(p) => p.parse().expect("Unable to parse specified port"),
        None => DEFAULT_PORT,
    };

    rouille::start_server(format!("localhost:{}", port), move |request| {
        router!(request,
            (POST) (/github/pull_request_event) => {
                let mut body = String::new();

                match request.data() {
                    None => rouille::Response::text("400 Bad Request")
                        .with_status_code(400),
                    Some(mut data) => {
                        try_or_400!(data.read_to_string(&mut body));

                        let commit_ref = match CommitRef::new(body.as_ref()) {
                            Ok(cr) => cr,
                            Err(_) => return internal_server_error(),
                        };

                        match jenkins::find_and_track_build_and_update_status(commit_ref) {
                            Ok(_) => {},
                            Err(_) => return internal_server_error(),
                        };

                        rouille::Response::text("202 Accepted")
                            .with_status_code(202)
                    }
                }
            },

            _ => rouille::Response::text("404 Not Found")
                    .with_status_code(404)
        )
    });
}