rPing: Implement email configuration and notification system [BETA]

- Added email configuration management with JSON file support.
- Created EmailService for sending alerts and test emails.
- Integrated email settings into the web interface with validation.
- Added endpoints for retrieving and updating email configuration.
- Implemented email notifications for failed device checks.
- Enhanced UI for email settings with variable insertion and recipient management.
- Updated styles for better visibility of status indicators in logs.

Author: karthik558

Cargo.lock

@@ -13,4 +13,15 @@ rocket = { version = "0.5", features = ["json"] }
 serde_json = "1.0"
 rand = "0.8"
 tokio = { version = "1", features = ["full"] }
-chrono = "0.4"
+chrono = "0.4"
+tokio-postgres = { version = "0.7", features = ["with-uuid-1", "with-serde_json-1"] }
+uuid = { version = "1.7", features = ["v4", "serde"] }
+dotenv = "0.15"
+futures = "0.3"
+async-trait = "0.1"
+thiserror = "1.0"
+anyhow = "1.0"
+tracing = "0.1"
+tracing-subscriber = "0.3"
+lettre = { version = "0.10", features = ["tokio1", "tokio1-native-tls"] }
+base64 = "0.21"

Cargo.toml

@@ -0,0 +1 @@
+{"smtp_server":"smtp.gmail.com","smtp_port":587,"sender_email":"","sender_password":"","recipients":[],"email_subject":"Failed Log Alert - {device_name}","email_body":"Device {device_name} failed at {date} {time}\nPing Status: {ping_status}\nHTTP Status: {http_status}\nBandwidth: {bandwidth}"}

email_config.json

@@ -0,0 +1,182 @@
+use anyhow::Result;
+use lettre::{
+    transport::smtp::authentication::Credentials,
+    AsyncSmtpTransport, AsyncTransport, Message, Tokio1Executor,
+};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use std::fs;
+use std::path::Path;
+use log::{info, error};
+
+const CONFIG_FILE: &str = "email_config.json";
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct EmailConfig {
+    pub smtp_server: String,
+    pub smtp_port: u16,
+    pub sender_email: String,
+    pub sender_password: String,
+    pub recipients: Vec<String>,
+    pub email_subject: String,
+    pub email_body: String,
+}
+
+impl Default for EmailConfig {
+    fn default() -> Self {
+        Self {
+            smtp_server: "smtp.gmail.com".to_string(),
+            smtp_port: 587,
+            sender_email: String::new(),
+            sender_password: String::new(),
+            recipients: Vec::new(),
+            email_subject: "Failed Log Alert - {device_name}".to_string(),
+            email_body: "Device {device_name} failed at {date} {time}\nPing Status: {ping_status}\nHTTP Status: {http_status}\nBandwidth: {bandwidth}".to_string(),
+        }
+    }
+}
+
+pub struct EmailService {
+    config: Arc<RwLock<EmailConfig>>,
+}
+
+impl EmailService {
+    pub fn new() -> Self {
+        let initial_config = Self::load_config_from_file()
+            .unwrap_or_else(|_| {
+                info!("No email configuration file found, using defaults");
+                EmailConfig::default()
+            });
+            
+        Self {
+            config: Arc::new(RwLock::new(initial_config)),
+        }
+    }
+
+    fn load_config_from_file() -> Result<EmailConfig> {
+        let config_path = Path::new(CONFIG_FILE);
+        if !config_path.exists() {
+            return Err(anyhow::anyhow!("Configuration file does not exist"));
+        }
+
+        let config_str = fs::read_to_string(config_path)?;
+        let config: EmailConfig = serde_json::from_str(&config_str)?;
+        Ok(config)
+    }
+
+    async fn save_config_to_file(&self) -> Result<()> {
+        let config = self.config.read().await;
+        let config_json = serde_json::to_string_pretty(&*config)?;
+        
+        // Write to a temporary file first to ensure atomic update
+        let temp_path = format!("{}.tmp", CONFIG_FILE);
+        fs::write(&temp_path, config_json)?;
+        
+        // Rename the temp file to the actual config file
+        fs::rename(&temp_path, CONFIG_FILE)?;
+        
+        info!("Email configuration saved successfully");
+        Ok(())
+    }
+
+    pub async fn update_config(&self, new_config: EmailConfig) -> Result<()> {
+        {
+            let mut config = self.config.write().await;
+            *config = new_config;
+        }
+        
+        // Save the updated config to file
+        self.save_config_to_file().await?;
+        Ok(())
+    }
+
+    pub async fn get_config(&self) -> EmailConfig {
+        self.config.read().await.clone()
+    }
+
+    pub async fn send_email(&self, device_name: &str, log_data: &LogData) -> Result<()> {
+        let config = self.config.read().await;
+        
+        if config.recipients.is_empty() {
+            return Err(anyhow::anyhow!("No recipients configured"));
+        }
+        
+        let subject = config.email_subject
+            .replace("{device_name}", device_name)
+            .replace("{date}", &log_data.date)
+            .replace("{time}", &log_data.time);
+
+        let body = config.email_body
+            .replace("{device_name}", device_name)
+            .replace("{date}", &log_data.date)
+            .replace("{time}", &log_data.time)
+            .replace("{ping_status}", &log_data.ping_status)
+            .replace("{http_status}", &log_data.http_status)
+            .replace("{bandwidth}", &log_data.bandwidth);
+
+        let mut email_builder = Message::builder()
+            .from(config.sender_email.parse()?)
+            .subject(subject)
+            .header(lettre::message::header::ContentType::TEXT_PLAIN);
+            
+        // Add all recipients
+        for recipient in &config.recipients {
+            email_builder = email_builder.to(recipient.parse()?);
+        }
+        
+        let email = email_builder.body(body)?;
+
+        let creds = Credentials::new(
+            config.sender_email.clone(),
+            config.sender_password.clone(),
+        );
+
+        let mailer = AsyncSmtpTransport::<Tokio1Executor>::relay(&config.smtp_server)?
+            .port(config.smtp_port)
+            .credentials(creds)
+            .build();
+
+        mailer.send(email).await?;
+        info!("Alert email sent to {} recipients for device {}", config.recipients.len(), device_name);
+        Ok(())
+    }
+
+    pub async fn send_test_email(&self, test_email: &str) -> Result<()> {
+        let config = self.config.read().await;
+        
+        if config.sender_email.is_empty() || config.sender_password.is_empty() {
+            return Err(anyhow::anyhow!("Sender email or password not configured"));
+        }
+        
+        let email = Message::builder()
+            .from(config.sender_email.parse()?)
+            .to(test_email.parse()?)
+            .subject("RustPing Test Email")
+            .header(lettre::message::header::ContentType::TEXT_PLAIN)
+            .body("This is a test email from RustPing. If you're receiving this, your email configuration is working correctly!".to_string())?;
+
+        let creds = Credentials::new(
+            config.sender_email.clone(),
+            config.sender_password.clone(),
+        );
+
+        let mailer = AsyncSmtpTransport::<Tokio1Executor>::relay(&config.smtp_server)?
+            .port(config.smtp_port)
+            .credentials(creds)
+            .build();
+
+        mailer.send(email).await?;
+        info!("Test email sent to {}", test_email);
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct LogData {
+    pub date: String,
+    pub time: String,
+    pub ping_status: String,
+    pub http_status: String,
+    pub bandwidth: String,
+} 

src/email.rs

@@ -3,6 +3,7 @@ extern crate rocket;
 
 mod models;
 mod sensors;
+mod email;
 
 use rocket::{get, post, delete, put, routes, State, response::Redirect, catch, catchers};
 use rocket::serde::json::Json;
@@ -27,6 +28,7 @@ use rocket::request::{self, Request, FromRequest};
 use rocket::outcome::Outcome;
 use serde::Deserialize;
 use rocket::serde::Serialize;
+use email::EmailService;
 
 async fn process_logs(start_date_parsed: Option<NaiveDate>, end_date_parsed: Option<NaiveDate>) -> Vec<String> {
     let mut filtered_logs = Vec::new();
@@ -689,6 +691,56 @@ async fn reload_devices_from_file(file_path: &str, devices: SharedDevices) {
 
 use env_logger;
 
+#[get("/api/email/config")]
+async fn get_email_config(email_service: &State<Arc<EmailService>>) -> Json<serde_json::Value> {
+    let config = email_service.get_config().await;
+    Json(json!(config))
+}
+
+#[post("/api/email/config", data = "<config>")]
+async fn update_email_config(
+    email_service: &State<Arc<EmailService>>,
+    config: Json<email::EmailConfig>,
+) -> Result<Json<serde_json::Value>, Status> {
+    match email_service.update_config(config.into_inner()).await {
+        Ok(_) => Ok(Json(json!({
+            "status": "success",
+            "message": "Email configuration updated successfully"
+        }))),
+        Err(e) => {
+            error!("Failed to update email config: {}", e);
+            Err(Status::InternalServerError)
+        }
+    }
+}
+
+#[derive(Deserialize)]
+struct TestEmailRequest {
+    test_email: String,
+}
+
+#[post("/api/email/config/test", data = "<request>")]
+async fn send_test_email(
+    email_service: &State<Arc<EmailService>>,
+    request: Json<TestEmailRequest>,
+) -> Result<Json<serde_json::Value>, Status> {
+    match email_service.send_test_email(&request.test_email).await {
+        Ok(_) => Ok(Json(json!({
+            "status": "success",
+            "message": "Test email sent successfully"
+        }))),
+        Err(e) => {
+            error!("Failed to send test email: {}", e);
+            Err(Status::InternalServerError)
+        }
+    }
+}
+
+#[get("/static/email_config.html")]
+async fn email_config_page(_auth: Auth) -> Option<NamedFile> {
+    NamedFile::open(Path::new("static/email_config.html")).await.ok()
+}
+
 #[tokio::main]
 async fn main() {
     // Initialize logger with debug level
@@ -698,8 +750,11 @@ async fn main() {
     info!("Starting RustPing Network Device Monitor...");
 
     let devices: SharedDevices = Arc::new(Mutex::new(Vec::new()));
+    let email_service = Arc::new(EmailService::new());
+    
     let rocket_instance = rocket::build()
         .manage(devices.clone())
+        .manage(email_service.clone())
         .mount("/static", FileServer::from(relative!("static")).rank(2))
         .mount("/", routes![
             index,
@@ -718,6 +773,10 @@ async fn main() {
             delete_web_device,
             manage_device,
             update_device,
+            get_email_config,
+            update_email_config,
+            send_test_email,
+            email_config_page,
         ])
         .register("/", catchers![unauthorized]);
 
@@ -737,6 +796,7 @@ async fn main() {
 
     // Spawn a background task.
     let devices_clone = devices.clone();
+    let email_service_clone = email_service.clone();
 
     tokio::spawn(async move {
         let mut device_statuses: HashMap<String, DeviceStatus> = HashMap::new();
@@ -823,19 +883,42 @@ async fn main() {
                             "N/A".to_string()
                         };
 
+                        let ping_status_str = status.ping_status.map_or("N/A", |s| if s { "OK" } else { "FAIL" });
+                        
                         let log_entry = format!(
                             "{} - {} ({}): Ping: {}, HTTP: {}, Bandwidth: {}\n",
                             now.format("%Y-%m-%d %H:%M:%S"),
                             dev.name,
                             dev.ip,
-                            status.ping_status.map_or("N/A", |s| if s { "OK" } else { "FAIL" }),
+                            ping_status_str,
                             http_status,
                             bandwidth
                         );
 
                         if let Err(e) = file.write_all(log_entry.as_bytes()) {
                             error!("Failed to write log entry: {}", e);
                         }
+                        
+                        // Send email notification if ping or HTTP status is FAIL
+                        if ping_status_str == "FAIL" || http_status == "FAIL" {
+                            // Create LogData for email
+                            let log_data = email::LogData {
+                                date: now.format("%Y-%m-%d").to_string(),
+                                time: now.format("%H:%M:%S").to_string(),
+                                ping_status: ping_status_str.to_string(),
+                                http_status: http_status.to_string(),
+                                bandwidth: bandwidth.clone(),
+                            };
+                            
+                            // Send email notification in a separate task to avoid blocking
+                            let device_name = dev.name.clone();
+                            let email_service_clone = email_service_clone.clone();
+                            tokio::spawn(async move {
+                                if let Err(e) = email_service_clone.send_email(&device_name, &log_data).await {
+                                    error!("Failed to send email notification: {}", e);
+                                }
+                            });
+                        }
                     }
                 }
             }