add ping and related options, methods and prepare release

Author: daywalker90

CHANGELOG.md

@@ -1,9 +1,12 @@
 # Changelog
 
-## [0.4.0] - Unreleased
+## [0.4.0] - 2024-10-20
 
 ### Added
-- more precise feedback if custom rule denies a peer, lists offending comparisons and their actual value
+- new custom rule variable ``ping``: check the time it takes to send a ``clnrod-pinglength`` bytes long message to the opening peer and back. Defaults to the average of 3 pings with 256 bytes length. Timeouts and errors will log but not flat out reject the channel, instead the timeout value of 5000 will be used. It is recommended to have email notifications on or watch the logs for ping timeouts (``Clnrod ping TIMEOUT``), since i encountered a rare case of CLN's ping getting stuck, requiring a node restart
+- new rpc method ``clnrod-testping`` *pubkey* [*count*] [*length*]: try the ping measurements with a few options
+- new option ``clnrod-pinglength``: set the length of the ping message for the custom rule check. Defaults to 256 bytes
+- more precise feedback if a custom rule rejects a peer, lists offending comparisons (non-exhaustive) that caused the rejection and their actual value
 
 ## [0.3.0] - 2024-09-23
 

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "clnrod"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 
 

Cargo.toml

@@ -54,6 +54,9 @@ New rpc methods with this plugin:
     * example: ``lightning-cli clnrod-testrule -k pubkey=02eadbd9e7557375161df8b646776a547c5cbc2e95b3071ec81553f8ec2cea3b8c public=true their_funding_sat=1000000 rule='amboss_terminal_web_rank < 1000'`` 
 * **clnrod-testmail**
     * send a test mail to check your email config
+* **clnrod-testping** *pubkey* [*count*] [*length*]
+    * measure the time it takes in ms to send a *length* (Default: 256) bytes message to the node with *pubkey* and back. Pings *count* (Default: 3) times. You must connect to the node first!
+
 
 ## Blockmode: allow
 Setting the blockmode to allow means:
@@ -87,6 +90,7 @@ The custom rule can make use of the following symbols:
 Variables starting with ``cln_`` query your own gossip, ``amboss_`` the [Amboss](https://amboss.space) API and ``oneml_`` the [1ML](https://1ml.com/) API. There is an one hour cache for collecting data that will be reset if you change the ``clnrod-customrule`` option.
 * ``their_funding_sat``: how much sats they are willing to open with on their side
 * ``public``: if the peer intends to open the channel as public this will be ``true`` otherwise ``false``
+* ``ping``: time it takes in ms to send a ``clnrod-pinglength`` (Default: 256) bytes packet to the opener and back. Timeouts and errors will log but not flat out reject the channel, instead the timeout value of 5000 will be used. It is recommended to have email notifications on or watch the logs for ping timeouts (``Clnrod ping TIMEOUT``), since i encountered a rare case of CLN's ping getting stuck, requiring a node restart
 * ``cln_node_capacity_sat``: the total capacity of the peer in sats
 * ``cln_channel_count``: the number of channels of the peer
 * ``cln_has_clearnet``: if the peer has any clearnet addresses published this will be ``true`` otherwise ``false``
@@ -127,6 +131,7 @@ You can mix two methods and if you set the same option with different methods, i
 * ``clnrod-denymessage``: The custom message we will send to a rejected peer, defaults to `CLNROD: Channel rejected by channel acceptor, sorry!`
 * ``clnrod-blockmode``: Set the preferred block mode to *allow* or *deny*, defaults to *deny* (with no config clnrod accepts all channels, see Documentation)
 * ``clnrod-customrule``: Set the custom rule for accepting channels, see Documentation, defaults to none
+* ``clnrod-pinglength``: Set the length of the ping message for the custom rule check. Defaults to `256` bytes
 ### email
 * ``clnrod-smtp-username``: smtp username for email notifications
 * ``clnrod-smtp-password``: smtp password for email notifications

README.md

@@ -1,6 +1,6 @@
 plugin:
   name: clnrod
-  version: 0.3.0
+  version: 0.4.0
   lang: rust
   install: |
     cargo build --release && cp target/release/clnrod . && cargo clean

coffee.yml

@@ -1,25 +1,29 @@
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
-    time::{Duration, SystemTime, UNIX_EPOCH},
+    time::{Duration, Instant, SystemTime, UNIX_EPOCH},
 };
 
 use anyhow::{anyhow, Error};
 use cln_plugin::Plugin;
 use cln_rpc::{
     model::{
-        requests::{ListchannelsRequest, ListnodesRequest},
+        requests::{GetinfoRequest, ListchannelsRequest, ListnodesRequest, PingRequest},
         responses::ListnodesNodesAddressesType,
     },
     primitives::{Amount, PublicKey},
     ClnRpc,
 };
-use log::debug;
+use log::{debug, info, warn};
 use serde_json::{json, Value};
-use tokio::time;
+use tokio::time::{self, timeout};
 
-use crate::structs::{
-    AmbossResponse, ChannelFlags, OneMl, PeerData, PeerDataCache, PeerInfo, PluginState,
+use crate::{
+    notify::notify,
+    structs::{
+        AmbossResponse, ChannelFlags, NotifyVerbosity, OneMl, PeerData, PeerDataCache, PeerInfo,
+        PluginState,
+    },
 };
 
 async fn get_oneml_data(
@@ -236,6 +240,7 @@ pub async fn collect_data(
     their_funding_msat: Amount,
     channel_flags: ChannelFlags,
     custom_rule: &str,
+    ping_length: u16,
 ) -> Result<PeerData, Error> {
     debug!("collect_data: start");
     let unix_now_s = SystemTime::now()
@@ -254,6 +259,15 @@ pub async fn collect_data(
     let network = plugin.configuration().network;
 
     debug!("collect_data: custom_rule: {}", custom_rule);
+    let ping_task = if custom_rule.to_ascii_lowercase().contains("ping") {
+        let plugin_ping = plugin.clone();
+        Some(tokio::spawn(async move {
+            ln_ping(plugin_ping, pubkey, 3, ping_length).await
+        }))
+    } else {
+        None
+    };
+
     let gossip_task = if custom_rule.to_ascii_lowercase().contains("cln_") {
         let channel_flags_clone = channel_flags.clone();
         Some(tokio::spawn(async move {
@@ -299,6 +313,13 @@ pub async fn collect_data(
         None
     };
 
+    let ping = if let Some(p) = ping_task {
+        let pings = p.await??;
+        Some((pings.iter().map(|y| *y as usize).sum::<usize>() / pings.len()) as u16)
+    } else {
+        None
+    };
+
     let peerinfo = if let Some(gdata) = gossip_task {
         gdata.await??
     } else {
@@ -330,6 +351,7 @@ pub async fn collect_data(
     debug!("collect_data: oneml_data: {:?}", oneml_data);
 
     let peer_data = PeerData {
+        ping,
         peerinfo,
         oneml_data,
         amboss_data,
@@ -376,3 +398,78 @@ fn check_feature(hex: &str, check_bits: Vec<u16>) -> Result<bool, Error> {
     }
     Ok(result)
 }
+
+pub async fn ln_ping(
+    plugin: Plugin<PluginState>,
+    pubkey: PublicKey,
+    count: u64,
+    ping_length: u16,
+) -> Result<Vec<u16>, Error> {
+    let timeout_ms = 5000;
+    let rpc_path =
+        Path::new(&plugin.configuration().lightning_dir).join(plugin.configuration().rpc_file);
+    let mut rpc = ClnRpc::new(rpc_path).await?;
+    let now_delay = Instant::now();
+    let _dummy_rpc = rpc.call_typed(&GetinfoRequest {}).await;
+    let rpc_delay = now_delay.elapsed().as_millis() as u16;
+    info!(
+        "Rpc delay that will be subtracted from ping: {}ms",
+        rpc_delay
+    );
+    let mut results = Vec::new();
+    let mut c = 0;
+    while c < count {
+        c += 1;
+        let now = Instant::now();
+        let timeout_result = match timeout(
+            Duration::from_millis(timeout_ms as u64),
+            rpc.call_typed(&PingRequest {
+                len: Some(ping_length),
+                pongbytes: Some(ping_length),
+                id: pubkey,
+            }),
+        )
+        .await
+        {
+            Ok(o) => o,
+            Err(e) => {
+                results.push(timeout_ms);
+                notify(
+                    &plugin,
+                    "Clnrod ping TIMEOUT.",
+                    &format!(
+                        "Pinging {} {}/{} times with {} bytes TIMED OUT: {}\
+                        \n Please check if the `lightning-cli ping` command is stuck for your \
+                        node and requires a restart of CLN",
+                        pubkey, c, count, ping_length, e
+                    ),
+                    Some(pubkey),
+                    NotifyVerbosity::Error,
+                )
+                .await;
+                break;
+            }
+        };
+        let ping_response = match timeout_result {
+            Ok(o) => o,
+            Err(e) => {
+                results.push(timeout_ms);
+                warn!("Ping error: {}", e);
+                time::sleep(Duration::from_millis(250)).await;
+                continue;
+            }
+        };
+        if ping_response.totlen < ping_length {
+            info!("Did not receive the full length ping back");
+        }
+        let ping = (now.elapsed().as_millis() as u16).saturating_sub(rpc_delay);
+        info!(
+            "Pinged {} {}/{} times with {} bytes in {}ms",
+            pubkey, c, count, ping_length, ping
+        );
+        results.push(ping);
+        time::sleep(Duration::from_millis(250)).await;
+    }
+
+    Ok(results)
+}

src/collect.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Error};
+use anyhow::{anyhow, Context, Error};
 use cln_plugin::{options, ConfiguredPlugin, Plugin};
 use cln_rpc::primitives::PublicKey;
 use cln_rpc::RpcError;
@@ -21,8 +21,8 @@ use crate::{
 };
 use crate::{
     OPT_BLOCK_MODE, OPT_CUSTOM_RULE, OPT_DENY_MESSAGE, OPT_EMAIL_FROM, OPT_EMAIL_TO,
-    OPT_NOTIFY_VERBOSITY, OPT_SMTP_PASSWORD, OPT_SMTP_PORT, OPT_SMTP_SERVER, OPT_SMTP_USERNAME,
-    PLUGIN_NAME,
+    OPT_NOTIFY_VERBOSITY, OPT_PING_LENGTH, OPT_SMTP_PASSWORD, OPT_SMTP_PORT, OPT_SMTP_SERVER,
+    OPT_SMTP_USERNAME, PLUGIN_NAME,
 };
 
 pub async fn read_config(
@@ -100,6 +100,9 @@ fn get_startup_options(
     if let Some(cr) = plugin.option_str(OPT_CUSTOM_RULE)? {
         check_option(&mut config, OPT_CUSTOM_RULE, &cr)?;
     };
+    if let Some(pl) = plugin.option_str(OPT_PING_LENGTH)? {
+        check_option(&mut config, OPT_PING_LENGTH, &pl)?;
+    };
     if let Some(smtp_user) = plugin.option_str(OPT_SMTP_USERNAME)? {
         check_option(&mut config, OPT_SMTP_USERNAME, &smtp_user)?;
     };
@@ -139,10 +142,21 @@ fn check_option(config: &mut Config, name: &str, value: &options::Value) -> Resu
             parse_rule(value.as_str().unwrap())?;
             config.custom_rule = value.as_str().unwrap().to_string();
         }
+        n if n.eq(OPT_PING_LENGTH) => {
+            let ping_length = u16::try_from(value.as_i64().unwrap())
+                .context(format!("{} out of valid range", OPT_PING_LENGTH))?;
+            if ping_length == 0 {
+                return Err(anyhow!("{} must be greater than 0", OPT_PING_LENGTH));
+            }
+            config.ping_length = ping_length;
+        }
         n if n.eq(OPT_SMTP_USERNAME) => config.smtp_username = value.as_str().unwrap().to_string(),
         n if n.eq(OPT_SMTP_PASSWORD) => config.smtp_password = value.as_str().unwrap().to_string(),
         n if n.eq(OPT_SMTP_SERVER) => config.smtp_server = value.as_str().unwrap().to_string(),
-        n if n.eq(OPT_SMTP_PORT) => config.smtp_port = u16::try_from(value.as_i64().unwrap())?,
+        n if n.eq(OPT_SMTP_PORT) => {
+            config.smtp_port = u16::try_from(value.as_i64().unwrap())
+                .context(format!("{} out of valid range", OPT_SMTP_PORT))?
+        }
         n if n.eq(OPT_EMAIL_FROM) => config.email_from = value.as_str().unwrap().to_string(),
         n if n.eq(OPT_EMAIL_TO) => config.email_to = value.as_str().unwrap().to_string(),
         n if n.eq(OPT_NOTIFY_VERBOSITY) => {
@@ -179,7 +193,7 @@ fn parse_option(name: &str, value: &serde_json::Value) -> Result<options::Value,
                 Err(anyhow!("{} is not a string!", OPT_CUSTOM_RULE))
             }
         }
-        n if n.eq(OPT_SMTP_PORT) => {
+        n if n.eq(OPT_SMTP_PORT) | n.eq(OPT_PING_LENGTH) => {
             if let Some(n_i64) = value.as_i64() {
                 return Ok(options::Value::Integer(n_i64));
             } else if let Some(n_str) = value.as_str() {