feat(tonic-xds): drive gRPC retry config from RDS RouteAction.retry_policy

tonic-xds/src/client/channel.rs

@@ -367,6 +367,18 @@ impl XdsChannelBuilder {
         resource_manager: XdsResourceManager,
     ) -> XdsChannelGrpc {
         let router: Arc<dyn Router> = Arc::new(XdsRouter::new(&cache));
+
+        // Retry config is control-plane-driven from RDS, per route. It is parsed
+        // and validated once, when the `RouteConfiguration` is validated. The
+        // routing layer (outer) stamps the matched route's shared retry config
+        // into the request's `RouteDecision`; the retry layer reads the shared
+        // config `Arc` and instantiates a per-request policy from it, so the
+        // request hot path does no parsing or allocation. The default below is
+        // the fallback used when a request carries no route retry config (non-xDS
+        // callers, or a route with no retry policy). See
+        // [`RetryLayer`](crate::client::retry::RetryLayer).
+        let retry_layer = RetryLayer::new(GrpcRetryPolicy::default());
+
         #[cfg(feature = "_tls-any")]
         let discovery: Arc<
             dyn ClusterDiscovery<EndpointAddress, EndpointChannel<Channel>>,
@@ -378,15 +390,13 @@ impl XdsChannelBuilder {
         let discovery: Arc<
             dyn ClusterDiscovery<EndpointAddress, EndpointChannel<Channel>>,
         > = Arc::new(XdsClusterDiscovery::new(cache, GrpcMakeConnector::new()));
-        let retry_policy = GrpcRetryPolicy::default();
 
         let resources = Arc::new(XdsChannelResources {
             _resource_manager: resource_manager,
             _xds_client: xds_client,
         });
 
         let routing_layer = XdsRoutingLayer::new(router, self.pre_route.clone(), self.authority());
-        let retry_layer = RetryLayer::new(retry_policy);
         let cluster_registry = Arc::new(ClusterClientRegistryGrpc::new());
         let lb_service = XdsLbService::new(cluster_registry, discovery);
         let inner = ServiceBuilder::new()
@@ -527,6 +537,7 @@ mod tests {
             Ok(RouteDecision {
                 cluster: "test-cluster".to_string(),
                 request_hash: None,
+                retry_config: None,
             })
         }
     }
@@ -680,9 +691,7 @@ mod tests {
 
         let retry_policy = GrpcRetryPolicy::new(
             RetryConfig::new().num_retries(1),
-            GrpcRetryClassifier {
-                retry_on: vec![tonic::Code::Unavailable],
-            },
+            GrpcRetryClassifier::new(vec![tonic::Code::Unavailable]),
         );
 
         let xds_channel = XdsChannelBuilder::new(test_config()).build_grpc_channel_from_parts(
@@ -734,6 +743,7 @@ mod tests {
                         match_fraction: None,
                     },
                     action: RouteConfigAction::Cluster(cluster_name.to_string()),
+                    retry_config: None,
                 }],
             }],
             metadata: Default::default(),

tonic-xds/src/client/circuit_breaking.rs

@@ -731,6 +731,7 @@ mod tests {
         request.extensions_mut().insert(RouteDecision {
             cluster: CLUSTER.to_string(),
             request_hash: None,
+            retry_config: None,
         });
         request
     }
@@ -984,9 +985,7 @@ mod tests {
                 RetryBackoffConfig::new(Duration::from_millis(1))
                     .max_interval(Duration::from_millis(1)),
             ),
-            GrpcRetryClassifier {
-                retry_on: vec![Code::Unavailable],
-            },
+            GrpcRetryClassifier::new(vec![Code::Unavailable]),
         );
         let calls = Arc::new(AtomicU32::new(0));
         let call_counter = calls.clone();

tonic-xds/src/client/loadbalance/pickers/ring_hash.rs

@@ -223,6 +223,7 @@ mod tests {
         r.extensions_mut().insert(RouteDecision {
             cluster: "c".to_string(),
             request_hash: hash,
+            retry_config: None,
         });
         r
     }