syncstat: send updates to Slack

jobs/tasks/sync_stat.cue

@@ -36,6 +36,7 @@ import (
 		env: true
 		data: """
 			RPC_NODE="http://{{ env "NOMAD_ADDR_rpc" }}"
+			SLACK_URL="{{with secret "kv/nomad-cluster/mainnet/slack"}}{{.Data.data.url}}{{end}}"
 			"""
 	}
 }

pkgs/syncstat/src/main.rs

@@ -1,11 +1,11 @@
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use percentage::Percentage;
 use restson::RestClient;
-use stat::{RPCData, RPCRender, RPCResult};
+use stat::{RPCData, RPCRender, RPCResult, SlackSend};
 use std::env;
 use std::sync::mpsc;
 use std::thread;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 mod stat;
 
@@ -15,6 +15,8 @@ extern crate log;
 fn main() -> Result<()> {
     pretty_env_logger::init();
 
+    let start_time = Instant::now();
+
     let (tx, rx) = mpsc::channel();
 
     let hours: u64 = match env::args().nth(1) {
@@ -25,6 +27,7 @@ fn main() -> Result<()> {
         })?,
         None => 12,
     };
+
     let timer = thread::spawn(move || {
         stat::timeout(hours);
         tx.send(()).unwrap();
@@ -35,6 +38,11 @@ fn main() -> Result<()> {
 
     let mut client = RestClient::new(&mantis_rpc_addr)?;
 
+    let slack_url = env::var("SLACK_URL")?;
+    debug!("RPC_NODE is {}", mantis_rpc_addr);
+
+    let mut slack_client = RestClient::new(&slack_url)?;
+
     let data: RPCData = RPCData {
         jsonrpc: String::from("2.0"),
         method: String::from("eth_syncing"),
@@ -57,6 +65,8 @@ fn main() -> Result<()> {
             RPCResult::Failure(_) => (0, 0),
         };
 
+        info!("{}", stat::format_time(start_time.elapsed().as_secs()));
+
         let delta = ratio.apply_to(highest_block);
 
         if (highest_block, current_block) == (0, 0)
@@ -66,14 +76,36 @@ fn main() -> Result<()> {
             if rx.try_recv().is_err() {
                 continue;
             } else {
-                break;
+                let message = format!(
+                    "Timed out after {} hours, before sync completed.",
+                    hours
+                );
+
+                let data: SlackSend = SlackSend {
+                    text: format!("Mainnet node: {}", message).to_owned(),
+                };
+
+                slack_client.post((), &data)?;
+
+                let err: Result<()> = Err(anyhow!(message));
+                return err;
             };
         }
-
         break;
     }
 
-    info!("sync is complete");
+    let message = format!(
+        "Sync completed.\n{}",
+        stat::format_time(start_time.elapsed().as_secs())
+    );
+
+    let data: SlackSend = SlackSend {
+        text: format!("Mainnet node: {}", message).to_owned(),
+    };
+
+    slack_client.post((), &data)?;
+
+    info!("{}", message);
 
     timer.join().ok();
 

pkgs/syncstat/src/stat.rs

@@ -30,6 +30,11 @@ pub struct ResultSuccess {
     pub pulled_states: u64,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SlackSend {
+    pub text: String,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum RPCResult {
@@ -57,7 +62,22 @@ impl RestPath<()> for RPCData {
     }
 }
 
+impl RestPath<()> for SlackSend {
+    fn get_path(_: ()) -> Result<String, restson::Error> {
+        Ok("".to_string())
+    }
+}
+
 pub fn timeout(hours: u64) {
     info!("Mantis node will run for {} hours.", hours);
     thread::sleep(Duration::new(hours * 60 * 60, 0));
 }
+
+pub fn format_time(secs: u64) -> String {
+    format!(
+        "time elapsed: {}:{}:{}",
+        secs / 60 / 60,
+        (secs / 60) % 60,
+        secs % 60
+    )
+}