Upgrade sim (#972)

* Add progress on duties refactor

* Add simple is_aggregator bool to val subscription

* Add the no-eth1-sim, refactor sim

tests/simulator/src/sync_sim.rs

@@ -1,10 +1,116 @@
 use crate::checks::{epoch_delay, verify_all_finalized_at};
 use crate::local_network::LocalNetwork;
-use futures::{Future, IntoFuture};
+use clap::ArgMatches;
+use futures::{future, Future, IntoFuture};
 use node_test_rig::ClientConfig;
+use node_test_rig::{environment::EnvironmentBuilder, testing_client_config, ValidatorConfig};
 use std::time::Duration;
 use types::{Epoch, EthSpec};
 
+pub fn run_syncing_sim(matches: &ArgMatches) -> Result<(), String> {
+    let initial_delay = value_t!(matches, "initial_delay", u64).unwrap_or(50);
+    let sync_delay = value_t!(matches, "sync_delay", u64).unwrap_or(10);
+    let speed_up_factor = value_t!(matches, "speedup", u64).unwrap_or(15);
+    let strategy = value_t!(matches, "strategy", String).unwrap_or("all".into());
+
+    println!("Syncing Simulator:");
+    println!(" initial_delay:{}", initial_delay);
+    println!(" sync delay:{}", sync_delay);
+    println!(" speed up factor:{}", speed_up_factor);
+    println!(" strategy:{}", strategy);
+
+    let log_level = "debug";
+    let log_format = None;
+
+    syncing_sim(
+        speed_up_factor,
+        initial_delay,
+        sync_delay,
+        strategy,
+        log_level,
+        log_format,
+    )
+}
+
+fn syncing_sim(
+    speed_up_factor: u64,
+    initial_delay: u64,
+    sync_delay: u64,
+    strategy: String,
+    log_level: &str,
+    log_format: Option<&str>,
+) -> Result<(), String> {
+    let mut env = EnvironmentBuilder::minimal()
+        .async_logger(log_level, log_format)?
+        .multi_threaded_tokio_runtime()?
+        .build()?;
+
+    let spec = &mut env.eth2_config.spec;
+    let end_after_checks = true;
+
+    spec.milliseconds_per_slot = spec.milliseconds_per_slot / speed_up_factor;
+    spec.min_genesis_time = 0;
+    spec.min_genesis_active_validator_count = 16;
+
+    let slot_duration = Duration::from_millis(spec.milliseconds_per_slot);
+    let context = env.core_context();
+    let num_validators = 8;
+    let beacon_config = testing_client_config();
+
+    let future = LocalNetwork::new(context, beacon_config.clone())
+        /*
+         * Add a validator client which handles all validators from the genesis state.
+         */
+        .and_then(move |network| {
+            network
+                .add_validator_client(ValidatorConfig::default(), 0, (0..num_validators).collect())
+                .map(|_| network)
+        })
+        /*
+         * Start the processes that will run checks on the network as it runs.
+         */
+        .and_then(move |network| {
+            // The `final_future` either completes immediately or never completes, depending on the value
+            // of `end_after_checks`.
+            let final_future: Box<dyn Future<Item = (), Error = String> + Send> =
+                if end_after_checks {
+                    Box::new(future::ok(()).map_err(|()| "".to_string()))
+                } else {
+                    Box::new(future::empty().map_err(|()| "".to_string()))
+                };
+
+            future::ok(())
+                // Check all syncing strategies one after other.
+                .join(pick_strategy(
+                    &strategy,
+                    network.clone(),
+                    beacon_config.clone(),
+                    slot_duration,
+                    initial_delay,
+                    sync_delay,
+                ))
+                .join(final_future)
+                .map(|_| network)
+        })
+        /*
+         * End the simulation by dropping the network. This will kill all running beacon nodes and
+         * validator clients.
+         */
+        .map(|network| {
+            println!(
+                "Simulation complete. Finished with {} beacon nodes and {} validator clients",
+                network.beacon_node_count(),
+                network.validator_client_count()
+            );
+
+            // Be explicit about dropping the network, as this kills all the nodes. This ensures
+            // all the checks have adequate time to pass.
+            drop(network)
+        });
+
+    env.runtime().block_on(future)
+}
+
 pub fn pick_strategy<E: EthSpec>(
     strategy: &str,
     network: LocalNetwork<E>,