[chain] Limit how many indexers (#19)

* add limited upload

* make config updates deterministic

Author: patrick-ogrady

chain/README.md

@@ -28,10 +28,10 @@ cargo run --bin setup -- generate --peers 10 --bootstrappers 2 --regions us-west
 ### [Optional] Configure Indexer Upload
 
 ```bash
-cargo run --bin setup -- indexer --dir assets --url <indexer URL>
+cargo run --bin setup -- indexer --count <uploaders> --dir assets --url <indexer URL>
 ```
 
-_The indexer URL is configured separately because it is typically only known after the threshold key is generated (derived in `setup generate`)._
+_The indexer URL is configured separately because it is typically only known after the threshold key is generated (derived in `setup generate`). The iteration order of this command is deterministic (re-running will update the same configuration files)._
 
 ### Build Validator Binary
 

chain/src/bin/setup.rs

@@ -98,6 +98,12 @@ fn main() {
         .subcommand(
             Command::new("indexer")
                 .about("Add indexer support for an alto chain.")
+                .arg(
+                    Arg::new("count")
+                        .long("count")
+                        .required(true)
+                        .value_parser(value_parser!(usize)),
+                )
                 .arg(
                     Arg::new("dir")
                         .long("dir")
@@ -276,6 +282,8 @@ fn generate(sub_matches: &ArgMatches) {
 
 fn indexer(sub_matches: &ArgMatches) {
     // Extract arguments
+    let count = *sub_matches.get_one::<usize>("count").unwrap();
+    assert!(count > 0, "count must be greater than zero");
     let dir = sub_matches.get_one::<String>("dir").unwrap().clone();
     let url = sub_matches.get_one::<String>("url").unwrap().clone();
 
@@ -290,56 +298,68 @@ fn indexer(sub_matches: &ArgMatches) {
         std::process::exit(1);
     }
 
-    // Iterate over all peer configuration files and add indexer URL
+    // Collect and sort file paths
+    let mut file_paths = Vec::new();
     for entry in fs::read_dir(&dir).unwrap() {
         let entry = entry.unwrap();
         let path = entry.path();
         if path.is_file() {
             if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
                 if file_name.ends_with(".yaml") && file_name != "config.yaml" {
-                    let relative_path = path.strip_prefix(&dir).unwrap();
-                    match fs::read_to_string(&path) {
-                        Ok(content) => match serde_yaml::from_str::<Config>(&content) {
-                            Ok(mut config) => {
-                                config.indexer = Some(url.clone());
-                                match serde_yaml::to_string(&config) {
-                                    Ok(updated_content) => {
-                                        if let Err(e) = fs::write(&path, updated_content) {
-                                            error!(
-                                                path = ?relative_path,
-                                                error = ?e,
-                                                "failed to write",
-                                            );
-                                        } else {
-                                            info!(path = ?relative_path, "updated");
-                                        }
-                                    }
-                                    Err(e) => {
-                                        error!(
-                                            path = ?relative_path,
-                                            error = ?e,
-                                            "failed to serialize config",
-                                        );
-                                    }
-                                }
-                            }
-                            Err(e) => {
+                    file_paths.push(path);
+                }
+            }
+        }
+    }
+    file_paths.sort();
+
+    // Iterate over sorted file paths and add indexer URL
+    let mut applied = 0;
+    for path in file_paths {
+        if applied >= count {
+            break;
+        }
+        let relative_path = path.strip_prefix(&dir).unwrap();
+        match fs::read_to_string(&path) {
+            Ok(content) => match serde_yaml::from_str::<Config>(&content) {
+                Ok(mut config) => {
+                    config.indexer = Some(url.clone());
+                    match serde_yaml::to_string(&config) {
+                        Ok(updated_content) => {
+                            if let Err(e) = fs::write(&path, updated_content) {
                                 error!(
                                     path = ?relative_path,
                                     error = ?e,
-                                    "failed to parse"
+                                    "failed to write",
                                 );
+                            } else {
+                                info!(path = ?relative_path, "updated");
+                                applied += 1;
                             }
-                        },
+                        }
                         Err(e) => {
                             error!(
                                 path = ?relative_path,
                                 error = ?e,
-                                "failed to read",
+                                "failed to serialize config",
                             );
                         }
                     }
                 }
+                Err(e) => {
+                    error!(
+                        path = ?relative_path,
+                        error = ?e,
+                        "failed to parse"
+                    );
+                }
+            },
+            Err(e) => {
+                error!(
+                    path = ?relative_path,
+                    error = ?e,
+                    "failed to read",
+                );
             }
         }
     }