dynamic_modules: support RING_HASH and MAGLEV cluster load balancing

Signed-off-by: Basundhara Chakrabarty <basundhara17061996@gmail.com>

Author: basundhara-c

changelogs/current/new_features/dynamic_modules__native-load-balancing-clusters.rst

@@ -1,5 +1,5 @@
 Dynamic module clusters (``envoy.clusters.dynamic_modules``) can now use
 Envoy's built-in load balancers. In addition to ``CLUSTER_PROVIDED``,
-``lb_policy`` may be set to ``LEAST_REQUEST``, ``ROUND_ROBIN``, or ``RANDOM``;
-the module then supplies only host discovery and Envoy performs host selection.
-Thread-aware policies (ring hash, maglev) are not supported.
+``lb_policy`` may be set to ``LEAST_REQUEST``, ``ROUND_ROBIN``, ``RANDOM``,
+``RING_HASH``, or ``MAGLEV``; the module then supplies only host discovery and
+Envoy performs host selection.

source/extensions/clusters/dynamic_modules/cluster.cc

@@ -878,22 +878,22 @@ DynamicModuleClusterFactory::createClusterWithConfig(
     const envoy::extensions::clusters::dynamic_modules::v3::ClusterConfig& proto_config,
     Upstream::ClusterFactoryContext& context) {
 
-  // Validate that the LB policy is one supported by dynamic_modules clusters.
-  // CLUSTER_PROVIDED (module LB) is always supported.
-  // LEAST_REQUEST, ROUND_ROBIN, RANDOM (native factory LB) are supported.
-  // Thread-aware policies (ring hash, maglev) are not supported.
+  // CLUSTER_PROVIDED uses the module's load balancer; the native policies use Envoy's factory
+  // load balancer, with the module supplying only host discovery.
   const auto policy = cluster.lb_policy();
   const bool is_module_lb = (policy == envoy::config::cluster::v3::Cluster::CLUSTER_PROVIDED);
   const bool is_native_lb = (policy == envoy::config::cluster::v3::Cluster::LEAST_REQUEST ||
                              policy == envoy::config::cluster::v3::Cluster::ROUND_ROBIN ||
-                             policy == envoy::config::cluster::v3::Cluster::RANDOM);
+                             policy == envoy::config::cluster::v3::Cluster::RANDOM ||
+                             policy == envoy::config::cluster::v3::Cluster::RING_HASH ||
+                             policy == envoy::config::cluster::v3::Cluster::MAGLEV);
 
   if (!is_module_lb && !is_native_lb) {
-    return absl::InvalidArgumentError(
-        fmt::format("cluster: LB policy {} is not valid for cluster type "
-                    "'envoy.clusters.dynamic_modules'. Supported policies are "
-                    "CLUSTER_PROVIDED, LEAST_REQUEST, ROUND_ROBIN, and RANDOM.",
-                    envoy::config::cluster::v3::Cluster::LbPolicy_Name(policy)));
+    return absl::InvalidArgumentError(fmt::format(
+        "cluster: LB policy {} is not valid for cluster type "
+        "'envoy.clusters.dynamic_modules'. Supported policies are CLUSTER_PROVIDED, "
+        "LEAST_REQUEST, ROUND_ROBIN, RANDOM, RING_HASH, and MAGLEV.",
+        envoy::config::cluster::v3::Cluster::LbPolicy_Name(policy)));
   }
 
   Server::Configuration::ServerFactoryContext& server_context = context.serverFactoryContext();

test/extensions/clusters/dynamic_modules/BUILD

@@ -28,7 +28,9 @@ envoy_cc_test(
         "//source/extensions/dynamic_modules:abi_impl",
         "//source/extensions/load_balancing_policies/cluster_provided:config",
         "//source/extensions/load_balancing_policies/least_request:config",
+        "//source/extensions/load_balancing_policies/maglev:config",
         "//source/extensions/load_balancing_policies/random:config",
+        "//source/extensions/load_balancing_policies/ring_hash:config",
         "//source/extensions/load_balancing_policies/round_robin:config",
         "//source/extensions/transport_sockets/raw_buffer:config",
         "//test/common/upstream:utility_lib",

test/extensions/clusters/dynamic_modules/cluster_test.cc

@@ -289,8 +289,8 @@ lb_policy: RANDOM
   EXPECT_EQ(nullptr, result->second);
 }
 
-// Test that thread-aware lb_policy like RING_HASH is rejected.
-TEST_F(DynamicModuleClusterTest, RingHashLbPolicyRejected) {
+// Test that RING_HASH lb_policy is accepted and returns nullptr thread-aware LB.
+TEST_F(DynamicModuleClusterTest, RingHashLbPolicy) {
   const std::string yaml = R"EOF(
 name: test_cluster
 connect_timeout: 0.25s
@@ -305,13 +305,14 @@ lb_policy: RING_HASH
 )EOF";
 
   auto result = createCluster(yaml);
-  ASSERT_FALSE(result.ok());
-  EXPECT_THAT(result.status().message(),
-              testing::HasSubstr("not valid for cluster type 'envoy.clusters.dynamic_modules'"));
+  ASSERT_TRUE(result.ok()) << result.status().message();
+  EXPECT_NE(nullptr, result->first);
+  // Native LB policies should return nullptr thread-aware LB.
+  EXPECT_EQ(nullptr, result->second);
 }
 
-// Test that thread-aware lb_policy like MAGLEV is rejected.
-TEST_F(DynamicModuleClusterTest, MaglevLbPolicyRejected) {
+// Test that MAGLEV lb_policy is accepted and returns nullptr thread-aware LB.
+TEST_F(DynamicModuleClusterTest, MaglevLbPolicy) {
   const std::string yaml = R"EOF(
 name: test_cluster
 connect_timeout: 0.25s
@@ -326,9 +327,10 @@ lb_policy: MAGLEV
 )EOF";
 
   auto result = createCluster(yaml);
-  ASSERT_FALSE(result.ok());
-  EXPECT_THAT(result.status().message(),
-              testing::HasSubstr("not valid for cluster type 'envoy.clusters.dynamic_modules'"));
+  ASSERT_TRUE(result.ok()) << result.status().message();
+  EXPECT_NE(nullptr, result->first);
+  // Native LB policies should return nullptr thread-aware LB.
+  EXPECT_EQ(nullptr, result->second);
 }
 
 // Test that a missing module fails gracefully.