vigil-server 1.29.0

Microservices Status Page. Monitors a distributed infrastructure and sends alerts (Slack, SMS, etc.).
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

// Vigil
//
// Microservices Status Page
// Copyright: 2018, Valerian Saliou <valerian@valeriansaliou.name>
// License: Mozilla Public License v2.0 (MPL v2.0)

use std::collections::HashMap;
use std::time::Duration;

use reqwest::blocking::Client;

use super::generic::{GenericNotifier, Notification, DISPATCH_TIMEOUT_SECONDS};
use crate::config::config::ConfigNotify;
use crate::APP_CONF;

static TEXT_MESSAGE_TRUNCATED_INDICATOR: &'static str = "[..]";

const TEXT_MESSAGE_MAXIMUM_LENGTH: usize = 1000;

lazy_static! {
    static ref TWILIO_HTTP_CLIENT: Client = Client::builder()
        .timeout(Duration::from_secs(DISPATCH_TIMEOUT_SECONDS))
        .gzip(true)
        .build()
        .unwrap();
}

pub struct TwilioNotifier;

impl GenericNotifier for TwilioNotifier {
    fn attempt(notify: &ConfigNotify, notification: &Notification) -> Result<(), bool> {
        if let Some(ref twilio) = notify.twilio {
            // Build up the message text
            let mut message = String::new();

            if notification.startup == true {
                message.push_str("Startup alert for: ");
            } else if notification.changed == false {
                message.push_str("Reminder for: ");
            }

            message.push_str(&format!("{}\n", APP_CONF.branding.page_title));
            message.push_str("\n");
            message.push_str(&format!("Status: {:?}\n", notification.status));
            message.push_str(&format!("Nodes: {}\n", &notification.replicas.join(", ")));
            message.push_str(&format!("Time: {}\n", &notification.time));

            // Trim down message to a maximum length? (most SMS receivers and networks support \
            //   up to 1600 characters by re-building message segments)
            if message.len() > TEXT_MESSAGE_MAXIMUM_LENGTH {
                debug!(
                    "message for Twilio notification is too long, trimming to length: {}",
                    TEXT_MESSAGE_MAXIMUM_LENGTH
                );

                message
                    .truncate(TEXT_MESSAGE_MAXIMUM_LENGTH - TEXT_MESSAGE_TRUNCATED_INDICATOR.len());

                message.push_str(TEXT_MESSAGE_TRUNCATED_INDICATOR);
            }

            debug!("will send Twilio notification with message: {}", &message);

            let mut has_sub_delivery_failure = false;

            for to_number in &twilio.to {
                // Build form parameters
                let mut params = HashMap::new();

                params.insert("MessagingServiceSid", &twilio.service_sid);
                params.insert("To", to_number);
                params.insert("Body", &message);

                // Submit message to Twilio
                let response = TWILIO_HTTP_CLIENT
                    .post(&generate_api_url(&twilio.account_sid))
                    .basic_auth(
                        twilio.account_sid.as_str(),
                        Some(twilio.auth_token.as_str()),
                    )
                    .form(&params)
                    .send();

                // Check for any failure
                if let Ok(response_inner) = response {
                    if response_inner.status().is_success() != true {
                        has_sub_delivery_failure = true;
                    }
                } else {
                    has_sub_delivery_failure = true;
                }
            }

            if has_sub_delivery_failure == true {
                return Err(true);
            }

            return Ok(());
        }

        Err(false)
    }

    fn can_notify(notify: &ConfigNotify, notification: &Notification) -> bool {
        if let Some(ref twilio_config) = notify.twilio {
            notification.expected(twilio_config.reminders_only)
        } else {
            false
        }
    }

    fn name() -> &'static str {
        "twilio"
    }
}

fn generate_api_url(account_sid: &str) -> String {
    format!(
        "https://api.twilio.com/2010-04-01/Accounts/{}/Messages.json",
        account_sid
    )
}