[fuzz] Added random load balancer fuzz

test/common/upstream/BUILD

@@ -242,6 +242,54 @@ envoy_cc_test(
     ],
 )
 
+envoy_cc_test_library(
+    name = "load_balancer_fuzz_lib",
+    srcs = ["load_balancer_fuzz_base.cc"],
+    hdrs = ["load_balancer_fuzz_base.h"],
+    deps = [
+        ":load_balancer_fuzz_proto_cc_proto",
+        ":utility_lib",
+        "//source/common/upstream:load_balancer_lib",
+        "//test/fuzz:random_lib",
+        "//test/mocks:common_lib",
+        "//test/mocks/runtime:runtime_mocks",
+        "//test/mocks/upstream:cluster_info_mocks",
+        "//test/mocks/upstream:host_set_mocks",
+        "//test/mocks/upstream:load_balancer_context_mock",
+        "//test/mocks/upstream:priority_set_mocks",
+        "@envoy_api//envoy/config/cluster/v3:pkg_cc_proto",
+    ],
+)
+
+envoy_proto_library(
+    name = "load_balancer_fuzz_proto",
+    srcs = ["load_balancer_fuzz.proto"],
+    deps = [
+        "//test/fuzz:common_proto",
+        "@envoy_api//envoy/config/cluster/v3:pkg",
+    ],
+)
+
+envoy_proto_library(
+    name = "random_load_balancer_fuzz_proto",
+    srcs = ["random_load_balancer_fuzz.proto"],
+    deps = [
+        "//test/common/upstream:load_balancer_fuzz_proto",
+    ],
+)
+
+envoy_cc_fuzz_test(
+    name = "random_load_balancer_fuzz_test",
+    srcs = ["random_load_balancer_fuzz_test.cc"],
+    corpus = "//test/common/upstream:random_load_balancer_corpus",
+    deps = [
+        ":load_balancer_fuzz_lib",
+        ":load_balancer_fuzz_proto_cc_proto",
+        ":random_load_balancer_fuzz_proto_cc_proto",
+        ":utility_lib",
+    ],
+)
+
 envoy_cc_test(
     name = "load_balancer_simulation_test",
     srcs = ["load_balancer_simulation_test.cc"],

test/common/upstream/load_balancer_fuzz.proto

@@ -0,0 +1,44 @@
+syntax = "proto3";
+
+package test.common.upstream;
+
+import "validate/validate.proto";
+import "envoy/config/cluster/v3/cluster.proto";
+import "google/protobuf/empty.proto";
+
+message UpdateHealthFlags {
+  // The host index determines what host set within the priority set which will get updated.
+  uint64 host_index = 1;
+  // These will determine how many hosts will get placed into health hosts, degraded hosts, and
+  // excluded hosts from the full host list.
+  uint32 num_healthy_hosts = 2;
+  uint32 num_degraded_hosts = 3;
+  uint32 num_excluded_hosts = 4;
+  // This is used to determine which hosts get marked as healthy, degraded, and excluded.
+  bytes random_bytestring = 5 [(validate.rules).bytes = {min_len: 1, max_len: 256}];
+}
+
+message LbAction {
+  oneof action_selector {
+    option (validate.required) = true;
+    UpdateHealthFlags update_health_flags = 1;
+    google.protobuf.Empty prefetch = 2;
+    google.protobuf.Empty choose_host = 3;
+  }
+}
+
+// This message represents what LoadBalancerFuzzBase will interact with, performing setup of host sets and calling into load balancers.
+// The logic that this message represents and the base class for load balancing fuzzing will be logic that maps to all types of load balancing
+// and can be used in a modular way at the highest level for each load balancer.
+message LoadBalancerTestCase {
+  envoy.config.cluster.v3.Cluster.CommonLbConfig common_lb_config = 1
+      [(validate.rules).message.required = true];
+  repeated LbAction actions = 2;
+
+  // TODO: Localities
+  repeated uint32 num_hosts_in_host_set = 3
+      [(validate.rules).repeated = {min_items: 1, max_items: 20}];
+
+  // This number is used to instantiate the prng. The prng takes the place of random() calls, allowing a representative random distribution which is also deterministic.
+  uint64 seed_for_prng = 4 [(validate.rules).uint64.gt = 0];
+}

test/common/upstream/load_balancer_fuzz_base.cc

@@ -0,0 +1,118 @@
+#include "test/common/upstream/load_balancer_fuzz_base.h"
+
+#include "test/common/upstream/utility.h"
+
+namespace Envoy {
+namespace Upstream {
+
+void LoadBalancerFuzzBase::initializeASingleHostSet(uint32_t num_hosts_in_host_set,
+                                                    uint8_t index_of_host_set) {
+  ENVOY_LOG_MISC(trace, "Will attempt to initialize host set {} with {} hosts.", index_of_host_set,
+                 num_hosts_in_host_set);
+  MockHostSet& host_set = *priority_set_.getMockHostSet(index_of_host_set);
+  uint32_t hosts_made = 0;
+  // Cap each host set at 256 hosts for efficiency
+  uint32_t max_num_hosts_in_host_set = 256;
+  // Leave port clause in for future changes
+  while (hosts_made < std::min(num_hosts_in_host_set, max_num_hosts_in_host_set) && port_ < 65535) {
+    host_set.hosts_.push_back(makeTestHost(info_, "tcp://127.0.0.1:" + std::to_string(port_)));
+    ++port_;
+    ++hosts_made;
+  }
+  // TODO: Random call and mod against host_set size for locality logic
+}
+
+// Initializes random and fixed host sets
+void LoadBalancerFuzzBase::initializeLbComponents(
+    const test::common::upstream::LoadBalancerTestCase& input) {
+  random_.initializeSeed(input.seed_for_prng());
+  uint8_t index_of_host_set = 0;
+  for (uint16_t num_hosts_in_host_set : input.num_hosts_in_host_set()) {
+    initializeASingleHostSet(num_hosts_in_host_set, index_of_host_set);
+    index_of_host_set++;
+  }
+  num_host_sets_ = index_of_host_set;
+}
+
+// Updating host sets is shared amongst all the load balancer tests. Since logically, we're just
+// setting the mock priority set to have certain values, and all load balancers interface with host
+// sets and their health statuses, this action maps to all load balancers.
+void LoadBalancerFuzzBase::updateHealthFlagsForAHostSet(uint64_t host_index,
+                                                        uint32_t num_healthy_hosts,
+                                                        uint32_t num_degraded_hosts,
+                                                        uint32_t num_excluded_hosts,
+                                                        std::string random_bytestring) {
+  uint8_t index_of_host_set = host_index % num_host_sets_;
+  ENVOY_LOG_MISC(trace, "Updating health flags for host set: {}", index_of_host_set);
+  MockHostSet& host_set = *priority_set_.getMockHostSet(index_of_host_set);
+  // This downcast will not overflow because size is capped by port numbers
+  uint32_t host_set_size = host_set.hosts_.size();
+  host_set.healthy_hosts_.clear();
+  host_set.degraded_hosts_.clear();
+  host_set.excluded_hosts_.clear();
+
+  Fuzz::ProperSubsetSelector subset_selector(random_bytestring);
+
+  std::vector<std::vector<uint8_t>> subsets = subset_selector.constructSubsets(
+      3, {num_healthy_hosts, num_degraded_hosts, num_excluded_hosts}, host_set_size);
+
+  // Healthy hosts are first subset
+  for (uint8_t index : subsets.at(0)) {
+    host_set.healthy_hosts_.push_back(host_set.hosts_[index]);
+    ENVOY_LOG_MISC(trace, "Index of host made healthy: {}", index);
+  }
+
+  // Degraded hosts are second subset
+  for (uint8_t index : subsets.at(1)) {
+    host_set.degraded_hosts_.push_back(host_set.hosts_[index]);
+    ENVOY_LOG_MISC(trace, "Index of host made degraded: {}", index);
+  }
+
+  // Excluded hosts are third subset
+  for (uint8_t index : subsets.at(1)) {
+    host_set.excluded_hosts_.push_back(host_set.hosts_[index]);
+    ENVOY_LOG_MISC(trace, "Index of host made excluded: {}", index);
+  }
+
+  host_set.runCallbacks({}, {});
+}
+
+void LoadBalancerFuzzBase::prefetch() {
+  // TODO: context, could generate it in proto action
+  lb_->peekAnotherHost(nullptr);
+}
+
+void LoadBalancerFuzzBase::chooseHost() {
+  // TODO: context, could generate it in proto action
+  lb_->chooseHost(nullptr);
+}
+
+void LoadBalancerFuzzBase::replay(
+    const Protobuf::RepeatedPtrField<test::common::upstream::LbAction>& actions) {
+  constexpr auto max_actions = 64;
+  for (int i = 0; i < std::min(max_actions, actions.size()); ++i) {
+    const auto& event = actions.at(i);
+    ENVOY_LOG_MISC(trace, "Action: {}", event.DebugString());
+    switch (event.action_selector_case()) {
+    case test::common::upstream::LbAction::kUpdateHealthFlags: {
+      updateHealthFlagsForAHostSet(event.update_health_flags().host_index(),
+                                   event.update_health_flags().num_healthy_hosts(),
+                                   event.update_health_flags().num_degraded_hosts(),
+                                   event.update_health_flags().num_excluded_hosts(),
+                                   event.update_health_flags().random_bytestring());
+      break;
+    }
+    case test::common::upstream::LbAction::kPrefetch:
+      prefetch();
+      break;
+    case test::common::upstream::LbAction::kChooseHost:
+      chooseHost();
+      break;
+    default:
+      break;
+    }
+  }
+}
+
+} // namespace Upstream
+} // namespace Envoy

test/common/upstream/load_balancer_fuzz_base.h

@@ -0,0 +1,58 @@
+#include "envoy/config/cluster/v3/cluster.pb.h"
+
+#include "common/upstream/load_balancer_impl.h"
+
+#include "test/common/upstream/load_balancer_fuzz.pb.validate.h"
+#include "test/fuzz/random.h"
+#include "test/mocks/common.h"
+#include "test/mocks/runtime/mocks.h"
+#include "test/mocks/upstream/cluster_info.h"
+#include "test/mocks/upstream/host_set.h"
+#include "test/mocks/upstream/load_balancer_context.h"
+#include "test/mocks/upstream/priority_set.h"
+
+namespace Envoy {
+namespace Upstream {
+
+// This class implements replay logic, and also handles the initial setup of static host sets and
+// the subsequent updates to those sets.
+class LoadBalancerFuzzBase {
+public:
+  LoadBalancerFuzzBase() : stats_(ClusterInfoImpl::generateStats(stats_store_)){};
+
+  // Untrusted upstreams don't have the ability to change the host set size, so keep it constant
+  // over the fuzz iteration.
+  void initializeASingleHostSet(uint32_t num_hosts_in_host_set, uint8_t index_of_host_set);
+
+  // Initializes load balancer components shared amongst every load balancer, random_, and
+  // priority_set_
+  void initializeLbComponents(const test::common::upstream::LoadBalancerTestCase& input);
+  void updateHealthFlagsForAHostSet(uint64_t host_index, uint32_t num_healthy_hosts,
+                                    uint32_t num_degraded_hosts, uint32_t num_excluded_hosts,
+                                    std::string random_bytestring);
+  // These two actions have a lot of logic attached to them. However, all the logic that the load
+  // balancer needs to run its algorithm is already encapsulated within the load balancer. Thus,
+  // once the load balancer is constructed, all this class has to do is call lb_->peekAnotherHost()
+  // and lb_->chooseHost().
+  void prefetch();
+  void chooseHost();
+  ~LoadBalancerFuzzBase() = default;
+  void replay(const Protobuf::RepeatedPtrField<test::common::upstream::LbAction>& actions);
+
+  // These public objects shared amongst all types of load balancers will be used to construct load
+  // balancers in specific load balancer fuzz classes
+  Stats::IsolatedStoreImpl stats_store_;
+  ClusterStats stats_;
+  NiceMock<Runtime::MockLoader> runtime_;
+  Random::PsuedoRandomGenerator64 random_;
+  NiceMock<MockPrioritySet> priority_set_;
+  std::shared_ptr<MockClusterInfo> info_{new NiceMock<MockClusterInfo>()};
+  std::unique_ptr<LoadBalancerBase> lb_;
+
+  // There are used to construct the priority set at the beginning of the fuzz iteration
+  uint16_t port_ = 80;
+  uint8_t num_host_sets_ = 0;
+};
+
+} // namespace Upstream
+} // namespace Envoy