Issue #168: Adding optional start and count values to sim.json file

Author: bjohnson5

sim-cli/src/main.rs

@@ -185,6 +185,8 @@ async fn main() -> anyhow::Result<()> {
         validated_activities.push(ActivityDefinition {
             source,
             destination,
+            start_secs: act.start_secs,
+            count: act.count,
             interval_secs: act.interval_secs,
             amount_msat: act.amount_msat,
         });

sim-lib/src/defined_activity.rs

@@ -5,14 +5,24 @@ use tokio::time::Duration;
 #[derive(Clone)]
 pub struct DefinedPaymentActivity {
     destination: NodeInfo,
+    start: Duration,
+    count: Option<u64>,
     wait: Duration,
     amount: u64,
 }
 
 impl DefinedPaymentActivity {
-    pub fn new(destination: NodeInfo, wait: Duration, amount: u64) -> Self {
+    pub fn new(
+        destination: NodeInfo,
+        start: Duration,
+        count: Option<u64>,
+        wait: Duration,
+        amount: u64,
+    ) -> Self {
         DefinedPaymentActivity {
             destination,
+            start,
+            count,
             wait,
             amount,
         }
@@ -36,6 +46,14 @@ impl DestinationGenerator for DefinedPaymentActivity {
 }
 
 impl PaymentGenerator for DefinedPaymentActivity {
+    fn payment_start(&self) -> Duration {
+        self.start
+    }
+
+    fn payment_count(&self) -> Option<u64> {
+        self.count
+    }
+
     fn next_payment_wait(&self) -> Duration {
         self.wait
     }
@@ -69,8 +87,13 @@ mod tests {
         let source = get_random_keypair();
         let payment_amt = 50;
 
-        let generator =
-            DefinedPaymentActivity::new(node.clone(), Duration::from_secs(60), payment_amt);
+        let generator = DefinedPaymentActivity::new(
+            node.clone(),
+            Duration::from_secs(0),
+            None,
+            Duration::from_secs(60),
+            payment_amt,
+        );
 
         let (dest, dest_capacity) = generator.choose_destination(source.1);
         assert_eq!(node.pubkey, dest.pubkey);

sim-lib/src/lib.rs

@@ -139,6 +139,12 @@ pub struct ActivityParser {
     /// The destination of the payment.
     #[serde(with = "serializers::serde_node_id")]
     pub destination: NodeId,
+    /// The time in the simulation to start the payment
+    #[serde(default)]
+    pub start_secs: u16,
+    /// The number of payments to send over the course of the simulation
+    #[serde(default)]
+    pub count: Option<u64>,
     /// The interval of the event, as in every how many seconds the payment is performed.
     pub interval_secs: u16,
     /// The amount of m_sat to used in this payment.
@@ -153,6 +159,10 @@ pub struct ActivityDefinition {
     pub source: NodeInfo,
     /// The destination of the payment.
     pub destination: NodeInfo,
+    /// The time in the simulation to start the payment
+    pub start_secs: u16,
+    /// The number of payments to send over the course of the simulation
+    pub count: Option<u64>,
     /// The interval of the event, as in every how many seconds the payment is performed.
     pub interval_secs: u16,
     /// The amount of m_sat to used in this payment.
@@ -261,6 +271,12 @@ pub trait DestinationGenerator: Send {
 pub struct PaymentGenerationError(String);
 
 pub trait PaymentGenerator: Display + Send {
+    /// Returns the time that the payments should start
+    fn payment_start(&self) -> Duration;
+
+    /// Returns the number of payments that should be made
+    fn payment_count(&self) -> Option<u64>;
+
     /// Returns the number of seconds that a node should wait until firing its next payment.
     fn next_payment_wait(&self) -> time::Duration;
 
@@ -667,6 +683,8 @@ impl Simulation {
             for description in self.activity.iter() {
                 let activity_generator = DefinedPaymentActivity::new(
                     description.destination.clone(),
+                    Duration::from_secs(description.start_secs.into()),
+                    description.count,
                     Duration::from_secs(description.interval_secs.into()),
                     description.amount_msat,
                 );
@@ -918,8 +936,21 @@ async fn produce_events<N: DestinationGenerator + ?Sized, A: PaymentGenerator +
     sender: Sender<SimulationEvent>,
     listener: Listener,
 ) -> Result<(), SimulationError> {
+    let mut current_count = 0;
     loop {
-        let wait = node_generator.next_payment_wait();
+        if let Some(c) = node_generator.payment_count() {
+            if c == current_count {
+                log::info!("Payment count has been met: {c} payments. Stopping the activity.");
+                return Ok(());
+            }
+        }
+
+        let wait: Duration = if current_count == 0 {
+            node_generator.payment_start()
+        } else {
+            node_generator.next_payment_wait()
+        };
+
         log::debug!("Next payment for {source} in {:?} seconds.", wait);
 
         select! {
@@ -956,6 +987,7 @@ async fn produce_events<N: DestinationGenerator + ?Sized, A: PaymentGenerator +
                     return Err(SimulationError::MpscChannelError (format!("Stopped random producer for {amount}: {source} -> {destination}.")));
                 }
 
+                current_count += 1;
             },
         }
     }

sim-lib/src/random_activity.rs

@@ -194,6 +194,16 @@ fn events_per_month(source_capacity_msat: u64, multiplier: f64, expected_payment
 }
 
 impl PaymentGenerator for RandomPaymentActivity {
+    /// Returns the time that the payments should start
+    fn payment_start(&self) -> Duration {
+        Duration::from_secs(0)
+    }
+
+    /// Returns the number of payments that should be made
+    fn payment_count(&self) -> Option<u64> {
+        None
+    }
+
     /// Returns the amount of time until the next payment should be scheduled for the node.
     fn next_payment_wait(&self) -> Duration {
         let mut rng = rand::thread_rng();