add optional name field to activities for easier logging and debugging

Author: Onyekachukwu-Nweke

Cargo.lock

@@ -27,6 +27,7 @@ futures = "0.3.30"
 console-subscriber = { version = "0.4.0", optional = true}
 tokio-util = { version = "0.7.13", features = ["rt"] }
 openssl = { version = "0.10", features = ["vendored"] }
+regex = "1.11.1"
 
 [features]
 dev = ["console-subscriber"]

sim-cli/Cargo.toml

@@ -8,13 +8,14 @@ use simln_lib::{
     ActivityDefinition, Amount, Interval, LightningError, LightningNode, NodeId, NodeInfo,
     Simulation, SimulationCfg, WriteResults,
 };
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::ops::AsyncFn;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use tokio_util::task::TaskTracker;
+use regex::Regex;
 
 /// The default directory where the simulation files are stored and where the results will be written to.
 pub const DEFAULT_DATA_DIR: &str = ".";
@@ -100,6 +101,9 @@ enum NodeConnection {
 /// [NodeId], which enables the use of public keys and aliases in the simulation description.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct ActivityParser {
+    /// Optional identifier for this activity.
+    #[serde(default)]
+    pub name: Option<String>,
     /// The source of the payment.
     #[serde(with = "serializers::serde_node_id")]
     pub source: NodeId,
@@ -259,9 +263,55 @@ async fn validate_activities(
     get_node_info: impl AsyncFn(&PublicKey) -> Result<NodeInfo, LightningError>,
 ) -> Result<Vec<ActivityDefinition>, LightningError> {
     let mut validated_activities = vec![];
+    let mut activity_names = HashSet::new();
 
     // Make all the activities identifiable by PK internally
-    for act in activity.into_iter() {
+    for (index, act) in activity.into_iter().enumerate() {
+        // Generate a default name if one is not provided
+        let name = match &act.name {
+            Some(name) => {
+                // Disallow empty names
+                if name.is_empty() {
+                    return Err(LightningError::ValidationError(
+                        "activity name cannot be empty".to_string()
+                    ));
+                }
+
+                // Disallow users from using the reserved "Activity-x" format
+                let reserved_pattern = Regex::new(r"^Activity-\d+$").unwrap();
+                if reserved_pattern.is_match(name) {
+                    return Err(LightningError::ValidationError(format!(
+                        "'{}' uses a reserved name format. 'Activity-{{number}}' is reserved for system use.",
+                        name
+                    )));
+                }
+
+                // Check for duplicate names
+                if !activity_names.insert(name.clone()) {
+                    return Err(LightningError::ValidationError(format!(
+                        "duplicate activity name: {}",
+                        name
+                    )));
+                }
+                name.clone()
+            },
+            None => {
+                // Generate a unique system name
+                let mut counter = index;
+                let mut unique_name;
+
+                loop {
+                    unique_name = format!("Activity-{}", counter);
+                    if activity_names.insert(unique_name.clone()) {
+                        break;
+                    }
+                    counter += 1;
+                }
+
+                unique_name
+            },
+        };
+
         // We can only map aliases to nodes we control, so if either the source or destination alias
         // is not in alias_node_map, we fail
         let source = if let Some(source) = match &act.source {
@@ -297,6 +347,7 @@ async fn validate_activities(
         };
 
         validated_activities.push(ActivityDefinition {
+            name: Some(name),
             source,
             destination,
             interval_secs: act.interval_secs,

sim-cli/src/parsing.rs

@@ -7,6 +7,8 @@ use tokio::time::Duration;
 
 #[derive(Clone)]
 pub struct DefinedPaymentActivity {
+    #[allow(dead_code)]
+    name: Option<String>,
     destination: NodeInfo,
     start: Option<Duration>,
     count: Option<u64>,
@@ -16,13 +18,15 @@ pub struct DefinedPaymentActivity {
 
 impl DefinedPaymentActivity {
     pub fn new(
+        name: Option<String>,
         destination: NodeInfo,
         start: Option<Duration>,
         count: Option<u64>,
         wait: ValueOrRange<u16>,
         amount: ValueOrRange<u64>,
     ) -> Self {
         DefinedPaymentActivity {
+            name,
             destination,
             start,
             count,
@@ -86,13 +90,15 @@ mod tests {
 
     #[test]
     fn test_defined_activity_generator() {
+        let name: String = "test_generator".to_string();
         let node = create_nodes(1, 100000);
         let node = &node.first().unwrap().0;
 
         let source = get_random_keypair();
         let payment_amt = 50;
 
         let generator = DefinedPaymentActivity::new(
+            Option::from(name),
             node.clone(),
             None,
             None,

simln-lib/src/defined_activity.rs

@@ -164,6 +164,8 @@ pub type Interval = ValueOrRange<u16>;
 /// This is constructed during activity validation and passed along to the [Simulation].
 #[derive(Debug, Clone)]
 pub struct ActivityDefinition {
+    /// Optional identifier for this activity.
+    pub name: Option<String>,
     /// The source of the payment.
     pub source: NodeInfo,
     /// The destination of the payment.
@@ -500,6 +502,7 @@ pub struct WriteResults {
 /// ExecutorKit contains the components required to spin up an activity configured by the user, to be used to
 /// spin up the appropriate producers and consumers for the activity.
 struct ExecutorKit {
+    name: Option<String>,
     source_info: NodeInfo,
     /// We use an arc mutex here because some implementations of the trait will be very expensive to clone.
     /// See [NetworkGraphView] for details.
@@ -806,6 +809,7 @@ impl Simulation {
         if !self.activity.is_empty() {
             for description in self.activity.iter() {
                 let activity_generator = DefinedPaymentActivity::new(
+                    description.name.clone(),
                     description.destination.clone(),
                     description
                         .start_secs
@@ -816,6 +820,7 @@ impl Simulation {
                 );
 
                 generators.push(ExecutorKit {
+                    name: description.name.clone(),
                     source_info: description.source.clone(),
                     // Defined activities have very simple generators, so the traits required are implemented on
                     // a single struct which we just cheaply clone.
@@ -874,6 +879,7 @@ impl Simulation {
 
         for (node_info, capacity) in active_nodes.values() {
             generators.push(ExecutorKit {
+                name: None,
                 source_info: node_info.clone(),
                 network_generator: network_generator.clone(),
                 payment_generator: Box::new(
@@ -958,9 +964,11 @@ impl Simulation {
             let pe_sender = sender.clone();
             tasks.spawn(async move {
                 let source = executor.source_info.clone();
+                let name = executor.name.as_deref().unwrap();
 
                 log::info!(
-                    "Starting activity producer for {}: {}.",
+                    "[{}] Starting activity producer for {}: {}.",
+                    name,
                     source,
                     executor.payment_generator
                 );

simln-lib/src/lib.rs

@@ -212,6 +212,7 @@ pub fn create_activity(
     amount_msat: u64,
 ) -> ActivityDefinition {
     ActivityDefinition {
+        name: None,
         source,
         destination,
         start_secs: None,