Extract a factory for limited-concurrency Coordinators

Author: shepmaster

compiler/base/orchestrator/src/coordinator.rs

@@ -2777,34 +2777,48 @@ mod tests {
             .unwrap_or(5)
     });
 
-    static CONCURRENT_TEST_SEMAPHORE: Lazy<Arc<Semaphore>> =
-        Lazy::new(|| Arc::new(Semaphore::new(*MAX_CONCURRENT_TESTS)));
-
-    struct LimitedCoordinator<T> {
-        _permit: OwnedSemaphorePermit,
-        coordinator: Coordinator<T>,
+    struct CoordinatorFactory {
+        semaphore: Arc<Semaphore>,
     }
 
-    impl<T> LimitedCoordinator<T>
-    where
-        T: Backend,
-    {
-        async fn with<F>(f: F) -> Self
+    impl CoordinatorFactory {
+        pub fn new(maximum: usize) -> Self {
+            Self {
+                semaphore: Arc::new(Semaphore::new(maximum)),
+            }
+        }
+
+        pub async fn build<B>(&self, backend: B) -> LimitedCoordinator<B>
         where
-            F: FnOnce() -> Coordinator<T>,
+            B: Backend,
         {
-            let semaphore = CONCURRENT_TEST_SEMAPHORE.clone();
+            let semaphore = self.semaphore.clone();
             let permit = semaphore
                 .acquire_owned()
                 .await
                 .expect("Unable to acquire permit");
-            let coordinator = f();
-            Self {
+
+            let coordinator = Coordinator::new(backend);
+
+            LimitedCoordinator {
                 _permit: permit,
                 coordinator,
             }
         }
+    }
+
+    static TEST_COORDINATOR_FACTORY: Lazy<CoordinatorFactory> =
+        Lazy::new(|| CoordinatorFactory::new(*MAX_CONCURRENT_TESTS));
 
+    struct LimitedCoordinator<T> {
+        _permit: OwnedSemaphorePermit,
+        coordinator: Coordinator<T>,
+    }
+
+    impl<T> LimitedCoordinator<T>
+    where
+        T: Backend,
+    {
         async fn shutdown(self) -> super::Result<T, super::Error> {
             self.coordinator.shutdown().await
         }
@@ -2825,11 +2839,11 @@ mod tests {
     }
 
     async fn new_coordinator_test() -> LimitedCoordinator<impl Backend> {
-        LimitedCoordinator::with(|| Coordinator::new(TestBackend::new())).await
+        TEST_COORDINATOR_FACTORY.build(TestBackend::new()).await
     }
 
     async fn new_coordinator_docker() -> LimitedCoordinator<impl Backend> {
-        LimitedCoordinator::with(|| Coordinator::new_docker()).await
+        TEST_COORDINATOR_FACTORY.build(DockerBackend(())).await
     }
 
     async fn new_coordinator() -> LimitedCoordinator<impl Backend> {