multi: add cfg struct to simulation

Nodes and activity are not included here, because we want to be
able to create our config struct separately from parsing of nodes
and activity. This reasoning will become more apparent in future
commits when we add two different running modes for the simulator
(regular operation and simulated network mode).

sim-cli/src/main.rs

@@ -1,4 +1,5 @@
 use bitcoin::secp256k1::PublicKey;
+use sim_lib::SimulationCfg;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -211,13 +212,15 @@ async fn main() -> anyhow::Result<()> {
     };
 
     let sim = Simulation::new(
+        SimulationCfg::new(
+            cli.total_time,
+            cli.expected_pmt_amt,
+            cli.capacity_multiplier,
+            write_results,
+            cli.fix_seed,
+        ),
         clients,
         validated_activities,
-        cli.total_time,
-        cli.expected_pmt_amt,
-        cli.capacity_multiplier,
-        write_results,
-        cli.fix_seed,
     );
     let sim2 = sim.clone();
 

sim-lib/src/lib.rs

@@ -474,15 +474,9 @@ impl MutRng {
     }
 }
 
+/// Contains the configuration options for our simulation.
 #[derive(Clone)]
-pub struct Simulation {
-    /// The lightning node that is being simulated.
-    nodes: HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>>,
-    /// The activity that are to be executed on the node.
-    activity: Vec<ActivityDefinition>,
-    /// High level triggers used to manage simulation tasks and shutdown.
-    shutdown_trigger: Trigger,
-    shutdown_listener: Listener,
+pub struct SimulationCfg {
     /// Total simulation time. The simulation will run forever if undefined.
     total_time: Option<time::Duration>,
     /// The expected payment size for the network.
@@ -498,6 +492,38 @@ pub struct Simulation {
     results: Arc<Mutex<PaymentResultLogger>>,
 }
 
+impl SimulationCfg {
+    pub fn new(
+        total_time: Option<u32>,
+        expected_payment_msat: u64,
+        activity_multiplier: f64,
+        write_results: Option<WriteResults>,
+        seed: Option<u64>,
+    ) -> Self {
+        Self {
+            total_time: total_time.map(|x| Duration::from_secs(x as u64)),
+            expected_payment_msat,
+            activity_multiplier,
+            write_results,
+            seeded_rng: MutRng::new(seed),
+            results: Arc::new(Mutex::new(PaymentResultLogger::new())),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Simulation {
+    /// Config for the simulation itself.
+    cfg: SimulationCfg,
+    /// The lightning node that is being simulated.
+    nodes: HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>>,
+    /// The activity that are to be executed on the node.
+    activity: Vec<ActivityDefinition>,
+    /// High level triggers used to manage simulation tasks and shutdown.
+    shutdown_trigger: Trigger,
+    shutdown_listener: Listener,
+}
+
 #[derive(Clone)]
 pub struct WriteResults {
     /// Data directory where CSV result files are written.
@@ -518,26 +544,17 @@ struct ExecutorKit {
 
 impl Simulation {
     pub fn new(
+        cfg: SimulationCfg,
         nodes: HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>>,
         activity: Vec<ActivityDefinition>,
-        total_time: Option<u32>,
-        expected_payment_msat: u64,
-        activity_multiplier: f64,
-        write_results: Option<WriteResults>,
-        seed: Option<u64>,
     ) -> Self {
         let (shutdown_trigger, shutdown_listener) = triggered::trigger();
         Self {
+            cfg,
             nodes,
             activity,
             shutdown_trigger,
             shutdown_listener,
-            total_time: total_time.map(|x| Duration::from_secs(x as u64)),
-            expected_payment_msat,
-            activity_multiplier,
-            write_results,
-            seeded_rng: MutRng::new(seed),
-            results: Arc::new(Mutex::new(PaymentResultLogger::new())),
         }
     }
 
@@ -623,7 +640,7 @@ impl Simulation {
     }
 
     pub async fn run(&self) -> Result<(), SimulationError> {
-        if let Some(total_time) = self.total_time {
+        if let Some(total_time) = self.cfg.total_time {
             log::info!("Running the simulation for {}s.", total_time.as_secs());
         } else {
             log::info!("Running the simulation forever.");
@@ -709,7 +726,7 @@ impl Simulation {
         });
 
         // Start a task that will shutdown the simulation if the total_time is met.
-        if let Some(total_time) = self.total_time {
+        if let Some(total_time) = self.cfg.total_time {
             let t = self.shutdown_trigger.clone();
             let l = self.shutdown_listener.clone();
 
@@ -743,11 +760,11 @@ impl Simulation {
     }
 
     pub async fn get_total_payments(&self) -> u64 {
-        self.results.lock().await.total_attempts()
+        self.cfg.results.lock().await.total_attempts()
     }
 
     pub async fn get_success_rate(&self) -> f64 {
-        self.results.lock().await.success_rate()
+        self.cfg.results.lock().await.success_rate()
     }
 
     /// run_data_collection starts the tasks required for the simulation to report of the results of the activity that
@@ -781,7 +798,7 @@ impl Simulation {
             }
         });
 
-        let result_logger = self.results.clone();
+        let result_logger = self.cfg.results.clone();
 
         let result_logger_clone = result_logger.clone();
         let result_logger_listener = listener.clone();
@@ -797,7 +814,7 @@ impl Simulation {
         });
 
         // csr: consume simulation results
-        let csr_write_results = self.write_results.clone();
+        let csr_write_results = self.cfg.write_results.clone();
         tasks.spawn(async move {
             log::debug!("Starting simulation results consumer.");
             if let Err(e) = consume_simulation_results(
@@ -864,9 +881,10 @@ impl Simulation {
         for (pk, node) in self.nodes.iter() {
             let chan_capacity = node.lock().await.list_channels().await?.iter().sum::<u64>();
 
-            if let Err(e) =
-                RandomPaymentActivity::validate_capacity(chan_capacity, self.expected_payment_msat)
-            {
+            if let Err(e) = RandomPaymentActivity::validate_capacity(
+                chan_capacity,
+                self.cfg.expected_payment_msat,
+            ) {
                 log::warn!("Node: {} not eligible for activity generation: {e}.", *pk);
                 continue;
             }
@@ -881,7 +899,7 @@ impl Simulation {
         let network_generator = Arc::new(Mutex::new(
             NetworkGraphView::new(
                 active_nodes.values().cloned().collect(),
-                self.seeded_rng.clone(),
+                self.cfg.seeded_rng.clone(),
             )
             .map_err(SimulationError::RandomActivityError)?,
         ));
@@ -898,9 +916,9 @@ impl Simulation {
                 payment_generator: Box::new(
                     RandomPaymentActivity::new(
                         *capacity,
-                        self.expected_payment_msat,
-                        self.activity_multiplier,
-                        self.seeded_rng.clone(),
+                        self.cfg.expected_payment_msat,
+                        self.cfg.activity_multiplier,
+                        self.cfg.seeded_rng.clone(),
                     )
                     .map_err(SimulationError::RandomActivityError)?,
                 ),