chore: resolve conflicts, clean up and improve code health

Author: Ifeanyichukwu

README.md

@@ -150,9 +150,7 @@ and destination nodes, you can provide `activity` descriptions of the
 source, destination, frequency and amount for payments that you'd like
 to execute. Note that `source` nodes _must_ be contained in `nodes`,
 but destination nodes can be any public node in the network (though
-this may result in liquidity draining over time). You can also add an optional name for each `activity` description that is
-used as the logging prefix to relate logs to their corresponding activity
-description (The index of each `activity` description will be used if a name is not provided for the `activity` description).
+this may result in liquidity draining over time).
 
 Required fields:
 ```
@@ -180,12 +178,6 @@ The example simulation file below sets up the following simulation:
 * Dispatch 1000 msat payments from `Bob` to `Dave` every 2 seconds.
 * Dispatch 10 payments (5000 msat each) from `Erin` to `Frank` at 2 second intervals, starting 20 seconds into the sim.
 
-- Connect to `Alice` running LND to generate activity.
-- Connect to `Bob` running CLN to generate activity.
-- Dispatch 2000 msat payments from `Alice` to `Carol` every 1 seconds.
-- Dispatch 140000 msat payments from `Bob` to `Alice` every 50 seconds.
-- Dispatch 1000 msat payments from `Bob` to `Dave` every 2 seconds.
-
 ```
 {
   "nodes": [

sim-cli/src/main.rs

@@ -95,6 +95,7 @@ async fn main() -> anyhow::Result<()> {
     let mut clients: HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>> = HashMap::new();
     let mut pk_node_map = HashMap::new();
     let mut alias_node_map = HashMap::new();
+    let mut activity_name_map = HashMap::new();
 
     for connection in nodes {
         // TODO: Feels like there should be a better way of doing this without having to Arc<Mutex<T>>> it at this time.
@@ -182,14 +183,15 @@ async fn main() -> anyhow::Result<()> {
             },
         };
 
-        for validated_activity in &validated_activities {
-            if validated_activity.activity_name == act.activity_name {
-                anyhow::bail!(LightningError::ValidationError(
-                    "Duplicate activity name is not allowed".to_string(),
-                ));
-            }
+        if activity_name_map.contains_key(&act.activity_name) {
+            anyhow::bail!(LightningError::ValidationError(format!(
+                "Duplicate activity name {:?} is not allowed.",
+                act.activity_name.unwrap()
+            ),));
         }
 
+        activity_name_map.insert(act.activity_name.clone(), act.clone());
+
         validated_activities.push(ActivityDefinition {
             source,
             destination,

sim-lib/src/defined_activity.rs

@@ -9,7 +9,6 @@ pub struct DefinedPaymentActivity {
     count: Option<u64>,
     wait: Duration,
     amount: u64,
-    activity_name: String,
 }
 
 impl DefinedPaymentActivity {
@@ -19,14 +18,13 @@ impl DefinedPaymentActivity {
         count: Option<u64>,
         wait: Duration,
         amount: u64,
-        activity_name: String) -> Self {
+    ) -> Self {
         DefinedPaymentActivity {
             destination,
             start,
             count,
             wait,
             amount,
-            activity_name,
         }
     }
 }
@@ -35,8 +33,8 @@ impl fmt::Display for DefinedPaymentActivity {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "{} activity: static payment of {} to {} every {:?}",
-            self.activity_name, self.amount, self.destination, self.wait
+            "static payment of {} to {} every {:?}",
+            self.amount, self.destination, self.wait
         )
     }
 }
@@ -88,7 +86,6 @@ mod tests {
 
         let source = get_random_keypair();
         let payment_amt = 50;
-        let activity_name = String::from("Coffee Purchase");
 
         let generator = DefinedPaymentActivity::new(
             node.clone(),
@@ -97,12 +94,6 @@ mod tests {
             Duration::from_secs(60),
             payment_amt,
         );
-        let generator = DefinedPaymentActivity::new(
-            node.clone(),
-            Duration::from_secs(60),
-            payment_amt,
-            activity_name,
-        );
 
         let (dest, dest_capacity) = generator.choose_destination(source.1);
         assert_eq!(node.pubkey, dest.pubkey);

sim-lib/src/lib.rs

@@ -716,7 +716,6 @@ impl Simulation {
                     description.count,
                     Duration::from_secs(description.interval_secs.into()),
                     description.amount_msat,
-                    activity_name.clone(),
                 );
 
                 generators.push(ExecutorKit {
@@ -861,15 +860,16 @@ impl Simulation {
                 let source = executor.source_info.clone();
 
                 log::info!(
-                    "Starting activity producer for {}: {}.",
+                    "Starting {} activity producer for {}: {}.",
+                    executor.activity_name,
                     source,
                     executor.payment_generator
                 );
 
                 if let Err(e) = produce_events(
                     executor.source_info,
                     executor.activity_name,
-                executor.network_generator,
+                    executor.network_generator,
                     executor.payment_generator,
                     pe_sender,
                     pe_listener,
@@ -972,11 +972,6 @@ async fn produce_events<N: DestinationGenerator + ?Sized, A: PaymentGenerator +
     listener: Listener,
 ) -> Result<(), SimulationError> {
     let mut current_count = 0;
-) {
-    log::info!(
-        "Started {activity_name} activity => activity producer for {source}: {node_generator}."
-    );
-
     loop {
         if let Some(c) = node_generator.payment_count() {
             if c == current_count {
@@ -1127,12 +1122,17 @@ impl PaymentResultLogger {
     }
 }
 
+// TODO: Add activity name and handle the initial processing log with few LOC
 impl Display for PaymentResultLogger {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let total_payments = self.success_payment + self.failed_payment;
+
+        // if self.activity_name
+
         write!(
             f,
-            "Processed {} payments sending {} msat total with {:.2}% success rate.",
+            "{} activity: Processed {} payments sending {} msat total with {:.2}% success rate.",
+            self.activity_name,
             total_payments,
             self.total_sent,
             (self.success_payment as f64 / total_payments as f64) * 100.0
@@ -1201,7 +1201,7 @@ async fn produce_simulation_results(
                                 }
                             },
                             SimulationOutput::SendPaymentFailure(payment, result) => {
-                                if results.send((payment, result.clone())).await.is_err() {
+                                if results.send((payment.clone(), result.clone())).await.is_err() {
                                     return Err(SimulationError::MpscChannelError(
                                         format!("Failed to send payment result: {result} for payment {:?} dispatched at {:?}.", payment.hash, payment.dispatch_time),
                                     ));
@@ -1272,7 +1272,7 @@ async fn track_payment_result(
         _ = listener.clone() => {
             log::debug!("Track payment result received a shutdown signal.");
         },
-        send_payment_result = results.send((payment, res.clone())) => {
+        send_payment_result = results.send((payment.clone(), res.clone())) => {
             if send_payment_result.is_err() {
                 return Err(SimulationError::MpscChannelError(format!("Failed to send payment result {res} for payment {payment}.")))
             }