webhook-gateway 2.17.2

A service to ingress github event
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
123
124
125
126

use anyhow::{anyhow, Result};
use once_cell::sync::OnceCell;
use std::env;
use std::process;
#[derive(Debug)]
pub struct ConfigEnv {
    pub backend_host: Option<String>,
    pub backend_port: Option<String>,
    pub backend_api_token: Option<String>,
    pub github_token: String,
    pub kafka_broker_list: String,
    pub kafka_topic: String,
    pub time_spent_topic: String,
}

impl ConfigEnv {
    pub fn new() -> Result<ConfigEnv> {
        let github_token = env::var("GITHUB_TOKEN");
        if github_token.is_err() {
            return Err(anyhow!(
                "GITHUB_TOKEN is required, please provide it by env variable GITHUB_TOKEN"
            ));
        }

        let kafka_broker_list = env::var("KAFKA_BROKER_LIST");
        if kafka_broker_list.is_err() {
            return Err(anyhow!(
                "KAFKA_BROKER_LIST is required, please provide it by env variable KAFKA_BROKER_LIST like localhost:9092"
            ));
        }

        let kafka_topic = env::var("KAFKA_TOPIC");
        if kafka_topic.is_err() {
            return Err(anyhow!(
                "KAFKA_TOPIC is required, please provide it by env variable KAFKA_TOPIC"
            ));
        }
        let mut time_spent_topic = env::var("KAFKA_TP_TOPIC");
        if time_spent_topic.is_err() {
            time_spent_topic = Ok("time_spent".to_string());
        }
        Ok(ConfigEnv {
            backend_host: env::var("BACKEND_HOST").ok(),
            backend_port: env::var("BACKEND_PORT").ok(),
            backend_api_token: env::var("BACKEND_API_TOKEN").ok(),
            github_token: github_token.unwrap(),
            kafka_broker_list: kafka_broker_list.unwrap(),
            kafka_topic: kafka_topic.unwrap(),
            time_spent_topic: time_spent_topic.unwrap(),
        })
    }
}

pub static CONFIG: OnceCell<ConfigEnv> = OnceCell::new();

pub fn is_backend_api_enable() -> bool {
    let config = CONFIG.get().expect("fail to get env variable");
    config.backend_host.is_some() && config.backend_port.is_some() && config.backend_api_token.is_some()
}
pub fn get_backend_host() -> &'static str {
    CONFIG
        .get()
        .expect("fail to get env variable")
        .backend_host
        .as_ref()
        .unwrap()
}
pub fn get_backend_port() -> &'static str {
    CONFIG
        .get()
        .expect("fail to get env variable")
        .backend_port
        .as_ref()
        .unwrap()
}
pub fn get_backend_api_token() -> &'static str {
    CONFIG
        .get()
        .expect("fail to get env variable")
        .backend_api_token
        .as_ref()
        .unwrap()
}
pub fn get_github_token() -> &'static str {
    &CONFIG.get().expect("fail to get env variable").github_token
}

pub fn get_kafka_broker_list() -> &'static str {
    &CONFIG
        .get()
        .expect("fail to get env variable")
        .kafka_broker_list
}
pub fn get_kafka_time_spent_topic() -> &'static str {
    &CONFIG
        .get()
        .expect("fail to get env variable")
        .time_spent_topic
}

pub fn get_kafka_topic() -> &'static str {
    &CONFIG.get().expect("fail to get env variable").kafka_topic
}
pub fn ensure_config() {
    match ConfigEnv::new() {
        Ok(c) => {
            if let Err(e) = CONFIG.set(c) {
                eprintln!("reading env variable failed: {:?}", e);
            }
        }

        Err(e) => {
            eprintln!("{}", e);
            process::exit(1);
        }
    }
    if is_backend_api_enable() {
        println!("{}", get_backend_host());
        println!("{}", get_backend_port());
        println!("{}", get_backend_api_token());
    }

    println!("{}", get_kafka_broker_list());
    println!("{}", get_kafka_topic());
    println!("{}", get_kafka_time_spent_topic());
}