feat: show individual build servers capacity in --dist-status

docs/DistributedQuickstart.md

@@ -143,6 +143,8 @@ You can check the status with `sccache --dist-status`, it should say something l
 
 ```
 $ sccache --dist-status
+{"SchedulerStatus":["https://sccache1.corpdmz.ber3.mozilla.com/",{"num_servers":3,"num_cpus":56,"in_progress":24,"servers":[{"address":"10.0.0.1:10501","num_cpus":16,"in_progress":8},{"address":"10.0.0.2:10501","num_cpus":20,"in_progress":8},{"address":"10.0.0.3:10501","num_cpus":20,"in_progress":8}]}]}
+```
 {"SchedulerStatus":["https://sccache1.corpdmz.ber3.mozilla.com/",{"num_servers":3,"num_cpus":56,"in_progress":24}]}
 ```
 

src/bin/sccache-dist/main.rs

@@ -740,10 +740,20 @@ impl SchedulerIncoming for Scheduler {
 
         self.prune_servers(&mut servers, &mut jobs);
 
+        let server_list: Vec<dist::BuildServerStatus> = servers
+            .iter()
+            .map(|(server_id, details)| dist::BuildServerStatus {
+                address: server_id.addr().to_string(),
+                num_cpus: details.num_cpus,
+                in_progress: details.jobs_assigned.len(),
+            })
+            .collect();
+
         Ok(SchedulerStatusResult {
             num_servers: servers.len(),
             num_cpus: servers.values().map(|v| v.num_cpus).sum(),
             in_progress: jobs.len(),
+            servers: server_list,
         })
     }
 }

src/dist/mod.rs

@@ -581,12 +581,21 @@ pub struct JobComplete {
 
 // Status
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct BuildServerStatus {
+    pub address: String,
+    pub num_cpus: usize,
+    pub in_progress: usize,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct SchedulerStatusResult {
     pub num_servers: usize,
     pub num_cpus: usize,
     pub in_progress: usize,
+    pub servers: Vec<BuildServerStatus>,
 }
 
 // SubmitToolchain

tests/dist.rs

@@ -174,6 +174,40 @@ fn test_dist_restartedserver() {
     });
 }
 
+#[test]
+#[cfg_attr(not(feature = "dist-tests"), ignore)]
+fn test_dist_scheduler_status_servers() {
+    let tmpdir = tempfile::Builder::new()
+        .prefix("sccache_dist_test")
+        .tempdir()
+        .unwrap();
+    let tmpdir = tmpdir.path();
+    let sccache_dist = harness::sccache_dist_path();
+
+    let mut system = harness::DistSystem::new(&sccache_dist, tmpdir);
+    system.add_scheduler();
+    system.add_server();
+
+    let sccache_cfg = dist_test_sccache_client_cfg(tmpdir, system.scheduler_url());
+    let sccache_cfg_path = tmpdir.join("sccache-cfg.json");
+    write_json_cfg(tmpdir, "sccache-cfg.json", &sccache_cfg);
+    let sccache_cached_cfg_path = tmpdir.join("sccache-cached-cfg");
+
+    stop_local_daemon();
+    start_local_daemon(&sccache_cfg_path, &sccache_cached_cfg_path);
+
+    let status = system.get_scheduler_status();
+    assert_eq!(status.num_servers, 1);
+    assert!(status.num_cpus > 0);
+    assert_eq!(status.in_progress, 0);
+    assert_eq!(status.servers.len(), 1);
+
+    let server = &status.servers[0];
+    assert!(!server.address.is_empty());
+    assert!(server.num_cpus > 0);
+    assert_eq!(server.in_progress, 0);
+}
+
 #[test]
 #[cfg_attr(not(feature = "dist-tests"), ignore)]
 fn test_dist_nobuilder() {

tests/harness/mod.rs

@@ -359,14 +359,15 @@ impl DistSystem {
         wait_for_http(scheduler_url, Duration::from_millis(100), MAX_STARTUP_WAIT);
         wait_for(
             || {
-                let status = self.scheduler_status();
+                let status = self.get_scheduler_status();
                 if matches!(
                     status,
                     SchedulerStatusResult {
                         num_servers: 0,
                         num_cpus: _,
-                        in_progress: 0
-                    }
+                        in_progress: 0,
+                        ref servers
+                    } if servers.is_empty()
                 ) {
                     Ok(())
                 } else {
@@ -533,15 +534,14 @@ impl DistSystem {
         wait_for_http(url, Duration::from_millis(100), MAX_STARTUP_WAIT);
         wait_for(
             || {
-                let status = self.scheduler_status();
-                if matches!(
-                    status,
-                    SchedulerStatusResult {
-                        num_servers: 1,
-                        num_cpus: _,
-                        in_progress: 0
-                    }
-                ) {
+                let status = self.get_scheduler_status();
+                if let SchedulerStatusResult {
+                    num_servers: 1,
+                    num_cpus: _,
+                    in_progress: 0,
+                    servers: _,
+                } = &status
+                {
                     Ok(())
                 } else {
                     Err(format!("{:?}", status))
@@ -557,7 +557,7 @@ impl DistSystem {
         HTTPUrl::from_url(reqwest::Url::parse(&url).unwrap())
     }
 
-    fn scheduler_status(&self) -> SchedulerStatusResult {
+    pub fn get_scheduler_status(&self) -> SchedulerStatusResult {
         let res = reqwest::blocking::get(dist::http::urls::scheduler_status(
             &self.scheduler_url().to_url(),
         ))