[router] refactor router and worker management 3/n (#10727)

sgl-router/src/core/worker_builder.rs

@@ -7,10 +7,7 @@ use std::collections::HashMap;
 
 /// Builder for creating BasicWorker instances with fluent API
 pub struct BasicWorkerBuilder {
-    // Required fields
     url: String,
-
-    // Optional fields with defaults
     api_key: Option<String>,
     worker_type: WorkerType,
     connection_mode: ConnectionMode,
@@ -21,7 +18,7 @@ pub struct BasicWorkerBuilder {
 }
 
 impl BasicWorkerBuilder {
-    /// Create a new builder with only the URL (defaults to Regular worker type)
+    /// Create a new builder with only the URL
     pub fn new(url: impl Into<String>) -> Self {
         Self {
             url: url.into(),
@@ -129,13 +126,10 @@ impl BasicWorkerBuilder {
 
 /// Builder for creating DPAwareWorker instances with fluent API
 pub struct DPAwareWorkerBuilder {
-    // Required fields
     base_url: String,
     api_key: Option<String>,
     dp_rank: usize,
     dp_size: usize,
-
-    // Optional fields with defaults
     worker_type: WorkerType,
     connection_mode: ConnectionMode,
     labels: HashMap<String, String>,
@@ -145,7 +139,7 @@ pub struct DPAwareWorkerBuilder {
 }
 
 impl DPAwareWorkerBuilder {
-    /// Create a new DP-aware worker builder (defaults to Regular worker type)
+    /// Create a new DP-aware worker builder
     pub fn new(base_url: impl Into<String>, dp_rank: usize, dp_size: usize) -> Self {
         Self {
             base_url: base_url.into(),
@@ -232,10 +226,7 @@ impl DPAwareWorkerBuilder {
 
     /// Build the DPAwareWorker instance
     pub fn build(self) -> DPAwareWorker {
-        // Create URL with DP rank suffix for identification
         let worker_url = format!("{}@{}", self.base_url, self.dp_rank);
-
-        // Use BasicWorkerBuilder to create a properly configured base worker
         let mut builder = BasicWorkerBuilder::new(worker_url)
             .worker_type(self.worker_type)
             .connection_mode(self.connection_mode)
@@ -243,18 +234,14 @@ impl DPAwareWorkerBuilder {
             .health_config(self.health_config)
             .circuit_breaker_config(self.circuit_breaker_config);
 
-        // Add gRPC client if provided
         if let Some(client) = self.grpc_client {
             builder = builder.grpc_client(client);
         }
-        // Add API key if provided
         if let Some(api_key) = self.api_key {
             builder = builder.api_key(api_key);
         }
 
         let base_worker = builder.build();
-
-        // Create the DPAwareWorker with the configured base worker
         DPAwareWorker::with_base_worker(base_worker, self.base_url, self.dp_rank, self.dp_size)
     }
 }
@@ -267,7 +254,6 @@ mod tests {
 
     #[test]
     fn test_basic_worker_builder_minimal() {
-        // Using new API - defaults to Regular type
         let worker = BasicWorkerBuilder::new("http://localhost:8080").build();
 
         assert_eq!(worker.url(), "http://localhost:8080");
@@ -278,7 +264,6 @@ mod tests {
 
     #[test]
     fn test_basic_worker_builder_with_type() {
-        // Test setting worker type explicitly
         let worker = BasicWorkerBuilder::new("http://localhost:8080")
             .worker_type(WorkerType::Decode)
             .build();
@@ -332,7 +317,6 @@ mod tests {
             ConnectionMode::Grpc { port: Some(50051) }
         );
         assert_eq!(worker.metadata().labels, labels);
-        // Can't directly compare HealthConfig without PartialEq, so check individual fields
         assert_eq!(
             worker.metadata().health_config.endpoint,
             health_config.endpoint
@@ -375,13 +359,11 @@ mod tests {
 
     #[test]
     fn test_dp_aware_worker_builder_minimal() {
-        // Using new API - defaults to Regular type
         let worker = DPAwareWorkerBuilder::new("http://localhost:8080", 2, 8).build();
 
         assert_eq!(worker.url(), "http://localhost:8080@2");
         assert_eq!(worker.dp_rank(), Some(2));
         assert_eq!(worker.dp_size(), Some(8));
-        // Note: base_url is a private field, we can only test through the url() method
         assert_eq!(worker.worker_type(), WorkerType::Regular);
     }
 
@@ -412,7 +394,6 @@ mod tests {
         assert_eq!(worker.dp_rank(), Some(3));
         assert_eq!(worker.dp_size(), Some(16));
         assert_eq!(worker.metadata().labels, labels);
-        // Can't directly compare HealthConfig without PartialEq, so check individual fields
         assert_eq!(
             worker.metadata().health_config.endpoint,
             health_config.endpoint
@@ -437,7 +418,6 @@ mod tests {
 
     #[test]
     fn test_dp_aware_worker_with_grpc() {
-        // Test that DPAwareWorkerBuilder can set a gRPC client
         let worker = DPAwareWorkerBuilder::new("grpc://cluster.local", 1, 4)
             .worker_type(WorkerType::Decode)
             .connection_mode(ConnectionMode::Grpc { port: Some(50051) })
@@ -456,9 +436,5 @@ mod tests {
             worker.metadata().labels.get("transport"),
             Some(&"grpc".to_string())
         );
-
-        // Note: We can't directly test the grpc_client as it's private,
-        // but the fact that the worker builds successfully with grpc connection mode
-        // validates that the configuration is properly passed through
     }
 }