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

use std::collections::HashMap;
use std::fmt::Debug;
use senderror::SendErrors;
use crate::config::Config;
use crate::destination::config::{DestinationConfig, MessageRoutingBehaviour};
use crate::message::{Level, Message};
use crate::message::author::Author;

pub mod message;
pub mod config;
pub mod destination;
pub mod error;

#[cfg(feature = "http")]
pub mod http_util;
mod senderror;

/// Send a message to all destinations as specified by the config
pub fn send_message(message: Message, config: &Config) -> Result<(), SendErrors> {

    let destinations = config.get_destinations();

    let mut errors = vec![];

    let mut sent_to_non_root_dest = false;

    for (i, dest) in destinations.iter().enumerate()
        .filter(|(_i, dest)| dest.get_routing_type().always_send_messages())
        .filter(|(_i, dest)| dest.should_receive(&message)) {

        match dest.send(&message) {
            Ok(()) => {
                if !dest.is_root() {
                    sent_to_non_root_dest = true;
                }
            }
            Err(err) => errors.push((err, i, dest)),
        };
    }

    if !sent_to_non_root_dest {
        // Find a drain.
        for (i, dest) in destinations.iter().enumerate()
            .filter(|(_i, dest)| dest.get_routing_type() == &MessageRoutingBehaviour::Drain)
            .filter(|(_i, dest)| dest.should_receive(&message)) {

            if let Err(err) = dest.send(&message) {
                errors.push((err, i, dest))
            }
        }
    }

    if errors.is_empty() {
        return Ok(());
    }

    if !destinations.iter().any(|dest| dest.is_root()) {
        let errors = errors.into_iter()
            .map(|(err, i, dest)| {
                let dest = dest.to_owned();
                (dest.to_owned(), i, err, HashMap::new())
            })
            .collect();
        return Err(SendErrors::new(vec![], message, errors));
    }

    let root: Vec<_> = destinations.iter()
        .filter(|dest| dest.is_root())
        .map(|dest| dest.to_owned())
        .collect();

    let errors = errors.into_iter().map(|(err, i, dest)| {
        let message = {
            SendError::from(&err, i, dest, &message)
        }.to_message();
        // Send any send errors to root destinations.
        let root_errors_indices = root.iter().enumerate()
            .map(|(i, dest)| (i, dest.send(&message)))
            .filter(|(_i, result)| result.is_err())
            .map(|(i, result)| (i, result.unwrap_err()))
            .collect();
        (dest.to_owned(), i, err, root_errors_indices)
    }).collect();

    Err(SendErrors::new(root, message, errors))
}

#[derive(Debug)]
pub struct SendError<'a> {
    err: &'a Box<dyn std::error::Error>,
    index: usize,
    item_string: String,
    message: &'a Message,
}

impl<'a> SendError<'a> {
    pub fn to_message(&self) -> Message {
        Message::new(Level::SelfError,
                     Some(format!("Failed to send notification to destination {}", self.index)),
                     message::MessageDetail::Raw(format!("Rnotify failed to send a message {:?} to destination '{}'. Error: '{}' A notification has been sent here because this is configured as a root logger.",
                                                         self.message, self.item_string, self.err)),
                     None,
                     Author::parse("rnotify".to_owned()),
                     self.message.get_unix_timestamp_millis().clone(),
        )
    }
}

impl<'a> SendError<'a> {
    pub fn from(err: &'a Box<dyn std::error::Error>, i: usize, item: &DestinationConfig, message: &'a Message) -> Self
    {
        Self {
            err,
            index: i,
            item_string: serde_json::to_string(item).unwrap_or_else(|_| format!("{:?}", item)),
            message,
        }
    }
}