[Thinkit/Tests] Add tunnel-decap tests for different tunnel-types and Adding NSF Reboot to CPU QoS With and Without Ixia tests

Author: kishanps

tests/forwarding/tunnel_decap_test.cc

@@ -55,13 +55,19 @@ static const auto dst_mac =
     netaddr::MacAddress(0x00, 0xaa, 0xbb, 0xcc, 0xcc, 0xdd);
 static const auto tunnel_dst_ipv6 = netaddr::Ipv6Address(
     0x11, 0x2233, 0x4455, 0x6677, 0x8899, 0xaabb, 0xccdd, 0xeeff);
+static const auto tunnel_dst_ipv6_wildcard =
+    netaddr::Ipv6Address(0x11, 0x2233, 0x4455, 0x6677, 0x8899, 0xaabb, 0, 0);
 static const auto tunnel_src_ipv6 = netaddr::Ipv6Address(
     0x1122, 0x1122, 0x3344, 0x3344, 0x5566, 0x5566, 0x7788, 0x7788);
+static const auto tunnel_src_ipv6_wildcard =
+    netaddr::Ipv6Address(0x1122, 0x1122, 0x3344, 0x3344, 0x5566, 0x5566, 0, 0);
 static const auto inner_dst_ipv4 = netaddr::Ipv4Address(0x10, 0, 0, 0x1);
 static const auto incorrect_dst_ipv6 = netaddr::Ipv6Address(
     0x77, 0x2233, 0x4455, 0x5577, 0x8899, 0xaabb, 0xccdd, 0xeeff);
 static const auto exact_match_mask = netaddr::Ipv6Address(
     0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff);
+static const auto ternary_match_mask =
+    netaddr::Ipv6Address(0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0, 0);
 static const auto inner_dst_ipv6 = netaddr::Ipv6Address(
     0x2001, 0xdb8, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888);
 
@@ -250,14 +256,24 @@ dvaas::PacketTestVector Ipv4InIpv6DecapTestVector(
 
 // Helper routine to install L3 route
 absl::StatusOr<std::vector<p4::v1::Entity>> InstallTunnelTermTable(
-    pdpi::P4RuntimeSession& switch_session, pdpi::IrP4Info& ir_p4info) {
+    pdpi::P4RuntimeSession& switch_session, pdpi::IrP4Info& ir_p4info,
+    const pins_test::TunnelMatchType tunnel_type) {
   std::vector<p4::v1::Entity> pi_entities;
   LOG(INFO) << "Installing Tunnel term table";
-  sai::Ipv6TunnelTerminationParams params;
-  params.dst_ipv6_value = tunnel_dst_ipv6;
-  params.dst_ipv6_mask = exact_match_mask;
-  params.src_ipv6_value = tunnel_src_ipv6;
-  params.src_ipv6_mask = exact_match_mask;
+  sai::Ipv6TunnelTerminationParams params{
+      .src_ipv6_value = tunnel_src_ipv6,
+      .src_ipv6_mask = exact_match_mask,
+      .dst_ipv6_value = tunnel_dst_ipv6,
+      .dst_ipv6_mask = exact_match_mask,
+  };
+
+  if (tunnel_type == pins_test::TunnelMatchType::kTernaryMatchSrcIp) {
+    params.src_ipv6_value = tunnel_src_ipv6_wildcard;
+    params.src_ipv6_mask = ternary_match_mask;
+  } else if (tunnel_type == pins_test::TunnelMatchType::kTernaryMatchDstIp) {
+    params.dst_ipv6_value = tunnel_dst_ipv6_wildcard;
+    params.dst_ipv6_mask = ternary_match_mask;
+  }
 
   sai::EntryBuilder entry_builder =
       sai::EntryBuilder().AddIpv6TunnelTerminationEntry(params);
@@ -298,6 +314,16 @@ TEST_P(TunnelDecapTestFixture, BasicTunnelTermDecapv4Inv6) {
   thinkit::MirrorTestbed& testbed =
       GetParam().mirror_testbed->GetMirrorTestbed();
 
+  // Set testbed environment
+  if (GetParam().tunnel_type == pins_test::TunnelMatchType::kExactMatch) {
+    testbed.Environment().SetTestCaseID("80ddbc10-4b85-4021-8093-0ac48e72b2de");
+  } else if (GetParam().tunnel_type ==
+             pins_test::TunnelMatchType::kTernaryMatchSrcIp) {
+    testbed.Environment().SetTestCaseID("d5bb5571-ecc0-4a46-aac4-02a0c7f79df9");
+  } else {
+    testbed.Environment().SetTestCaseID("e986d859-59ec-4a8f-acc0-c586cecf0eb2");
+  }
+
   // Initialize the connection, clear all entities, and (for the SUT) push
   // P4Info.
   ASSERT_OK_AND_ASSIGN(std::unique_ptr<pdpi::P4RuntimeSession> sut_p4rt_session,
@@ -324,7 +350,8 @@ TEST_P(TunnelDecapTestFixture, BasicTunnelTermDecapv4Inv6) {
   // Install tunnel term table entry on SUT
   ASSERT_OK_AND_ASSIGN(
       const auto tunnel_entities,
-      InstallTunnelTermTable(*sut_p4rt_session.get(), sut_ir_p4info));
+      InstallTunnelTermTable(*sut_p4rt_session.get(), sut_ir_p4info,
+                             GetParam().tunnel_type));
 
   LOG(INFO) << "Sending IPv4-in-IPv6 Packet from ing:" << in_port
             << " to eng:" << out_port;
@@ -347,14 +374,14 @@ TEST_P(TunnelDecapTestFixture, BasicTunnelTermDecapv4Inv6) {
   EXPECT_OK(validation_result.HasSuccessRateOfAtLeast(1.0));
 
   // Send IPv4-in-IPv6 with wrong dst_ipv6 Packet and Verify
-  pins_test::TunnelDecapTestVectorParams tunel_v6_mismatch{
+  pins_test::TunnelDecapTestVectorParams tunnel_v6_mismatch{
       .in_port = in_port,
       .out_port = out_port,
       .dst_mac = dst_mac,
       .inner_dst_ipv4 = inner_dst_ipv4,
       .dst_ipv6 = incorrect_dst_ipv6};
   dvaas::PacketTestVector test_vector =
-      Ipv4InIpv6DecapTestVector(tunel_v6_mismatch);
+      Ipv4InIpv6DecapTestVector(tunnel_v6_mismatch);
 
   for (dvaas::SwitchOutput& output :
        *test_vector.mutable_acceptable_outputs()) {
@@ -378,6 +405,16 @@ TEST_P(TunnelDecapTestFixture, BasicTunnelTermDecapv6Inv6) {
   thinkit::MirrorTestbed& testbed =
       GetParam().mirror_testbed->GetMirrorTestbed();
 
+  // Set testbed environment
+  if (GetParam().tunnel_type == pins_test::TunnelMatchType::kExactMatch) {
+    testbed.Environment().SetTestCaseID("79060cd7-6001-4925-85e5-4bb8b1ec56ae");
+  } else if (GetParam().tunnel_type ==
+             pins_test::TunnelMatchType::kTernaryMatchSrcIp) {
+    testbed.Environment().SetTestCaseID("6b0297a7-75cd-412b-be24-61c8fb363399");
+  } else {
+    testbed.Environment().SetTestCaseID("b7716ba9-4266-48dc-9815-10093603f597");
+  }
+
   // Initialize the connection, clear all entities, and (for the SUT) push
   // P4Info.
   ASSERT_OK_AND_ASSIGN(std::unique_ptr<pdpi::P4RuntimeSession> sut_p4rt_session,
@@ -404,7 +441,8 @@ TEST_P(TunnelDecapTestFixture, BasicTunnelTermDecapv6Inv6) {
   // Install tunnel term table entry on SUT
   ASSERT_OK_AND_ASSIGN(
       const auto tunnel_entities,
-      InstallTunnelTermTable(*sut_p4rt_session.get(), sut_ir_p4info));
+      InstallTunnelTermTable(*sut_p4rt_session.get(), sut_ir_p4info,
+                             GetParam().tunnel_type));
 
   LOG(INFO) << "Sending IPv6-in-IPv6 Packet for packet match from in:"
             << in_port << " to out:" << out_port;

tests/forwarding/tunnel_decap_test.h

@@ -31,13 +31,20 @@
 
 namespace pins_test {
 
+enum class TunnelMatchType {
+  kExactMatch,         // exact match on src-ip and dst-ip
+  kTernaryMatchSrcIp,  // ternary match on src-ip and exact match on dst-ip
+  kTernaryMatchDstIp,  // ternary match on dst-ip and exact match on src-ip
+};
+
 struct TunnelDecapTestParams {
   // Using a shared_ptr because parameterized tests require objects to be
   // copyable.
   std::shared_ptr<thinkit::MirrorTestbedInterface> mirror_testbed;
   // Pushed to the SUT if given, otherwise assumes the correct one is already
   // configured.
   std::optional<p4::config::v1::P4Info> sut_p4info;
+  TunnelMatchType tunnel_type;
   std::string test_name;
   dvaas::DataplaneValidationParams dvaas_params;
   std::shared_ptr<dvaas::DataplaneValidator> dvaas;

tests/integration/system/nsf/BUILD.bazel

@@ -44,6 +44,7 @@ cc_library(
         "//thinkit:switch",
         "@com_github_google_glog//:glog",
         "@com_github_grpc_grpc//:grpc++",
+        "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
@@ -78,7 +79,7 @@ cc_library(
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
-        "@com_google_googletest//:gtest_main",
+        "@com_google_googletest//:gtest",
     ],
     alwayslink = True,
 )

tests/integration/system/nsf/flow_programmers/BUILD.bazel

@@ -26,6 +26,7 @@ cc_library(
     deps = [
         "//tests/integration/system/nsf/interfaces:flow_programmer",
         "//tests/integration/system/nsf/interfaces:testbed",
+        "//thinkit:ssh_client",
         "@com_github_p4lang_p4runtime//:p4info_cc_proto",
         "@com_google_absl//absl/status",
     ],

tests/integration/system/nsf/flow_programmers/fuzzer_replay_programmer.h

@@ -19,13 +19,15 @@
 #include "p4/config/v1/p4info.pb.h"
 #include "tests/integration/system/nsf/interfaces/flow_programmer.h"
 #include "tests/integration/system/nsf/interfaces/testbed.h"
+#include "thinkit/ssh_client.h"
 
 namespace pins_test {
 
 class FuzzerReplayProgrammer : public FlowProgrammer {
  public:
    absl::Status ProgramFlows(const p4::config::v1::P4Info &p4_info,
-                             Testbed &testbed) override {
+                             Testbed &testbed,
+                             thinkit::SSHClient &ssh_client) override {
      return absl::OkStatus();
    };
   absl::Status ClearFlows(Testbed& testbed) override {

tests/integration/system/nsf/interfaces/BUILD.bazel

@@ -37,6 +37,7 @@ cc_library(
     hdrs = ["flow_programmer.h"],
     deps = [
         ":testbed",
+        "//thinkit:ssh_client",
         "@com_github_p4lang_p4runtime//:p4info_cc_proto",
         "@com_google_absl//absl/status",
     ],

tests/integration/system/nsf/interfaces/flow_programmer.h

@@ -18,6 +18,7 @@
 #include "absl/status/status.h"
 #include "p4/config/v1/p4info.pb.h"
 #include "tests/integration/system/nsf/interfaces/testbed.h"
+#include "thinkit/ssh_client.h"
 
 namespace pins_test {
 
@@ -30,10 +31,10 @@ class FlowProgrammer {
  public:
   virtual ~FlowProgrammer() = default;
 
-  // Programs a predefined flow on the SUT based on the given IP version and
-  // protocol.
+  // Programs predefined flows on the SUT.
   virtual absl::Status ProgramFlows(const p4::config::v1::P4Info &p4_info,
-                                    Testbed &testbed) = 0;
+                                    Testbed &testbed,
+                                    thinkit::SSHClient &ssh_client) = 0;
 
   // Clears all flows on the SUT.
   virtual absl::Status ClearFlows(Testbed& testbed) = 0;

tests/integration/system/nsf/nsf_acl_flow_coverage_test.cc

@@ -114,8 +114,7 @@ TEST_P(NsfAclFlowCoverageTestFixture, NsfAclFlowCoverageTest) {
   ImageConfigParams image_config_param = GetParam().image_config_params[0];
   thinkit::Switch& sut = GetSut(testbed_);
 
-  ASSERT_OK(ValidateTestbedState(image_config_param.image_label, testbed_,
-                                 *ssh_client_, image_config_param.gnmi_config));
+  ASSERT_OK(ValidateTestbedState(testbed_, *ssh_client_, &image_config_param));
   ASSERT_OK(StoreSutDebugArtifacts(
       absl::StrCat(image_config_param.image_label, "_before_nsf_reboot"),
       testbed_));
@@ -132,8 +131,8 @@ TEST_P(NsfAclFlowCoverageTestFixture, NsfAclFlowCoverageTest) {
 
   // Program all the flows.
   LOG(INFO) << "Programming L3 flows before starting the traffic";
-  ASSERT_OK(
-      flow_programmer_->ProgramFlows(image_config_param.p4_info, testbed_));
+  ASSERT_OK(flow_programmer_->ProgramFlows(image_config_param.p4_info, testbed_,
+                                           *ssh_client_));
   LOG(INFO) << "Programming ACL flows";
   ASSERT_OK(ProgramAclFlows(sut, image_config_param.p4_info));
 
@@ -152,8 +151,7 @@ TEST_P(NsfAclFlowCoverageTestFixture, NsfAclFlowCoverageTest) {
   ASSERT_OK(pins_test::NsfReboot(testbed_));
   ASSERT_OK(WaitForNsfReboot(testbed_, *ssh_client_));
 
-  ASSERT_OK(ValidateTestbedState(image_config_param.image_label, testbed_,
-                                 *ssh_client_, image_config_param.gnmi_config));
+  ASSERT_OK(ValidateTestbedState(testbed_, *ssh_client_, &image_config_param));
   ASSERT_OK(StoreSutDebugArtifacts(
       absl::StrCat(image_config_param.image_label, "_after_nsf_reboot"),
       testbed_));

tests/integration/system/nsf/upgrade_test.cc

@@ -52,6 +52,8 @@ using ::p4::v1::ReadResponse;
 constexpr int kErrorPercentage = 1;
 constexpr absl::Duration kTrafficRunDuration = absl::Minutes(15);
 
+// TODO: Compare and look into possibility of using a better
+// approach than using std::variant (eg. type-erasure or typed tests).
 void NsfUpgradeTest::SetUp() {
   flow_programmer_ = GetParam().create_flow_programmer();
   traffic_helper_ = GetParam().create_traffic_helper();
@@ -69,9 +71,8 @@ absl::Status NsfUpgradeTest::NsfUpgradeOrReboot(
   LOG(INFO) << "Initiating NSF Upgrade from: " << curr_image_config.image_label
             << " to: " << next_image_config.image_label;
 
-  RETURN_IF_ERROR(ValidateTestbedState(curr_image_config.image_label, testbed_,
-                                       *ssh_client_,
-                                       curr_image_config.gnmi_config));
+  RETURN_IF_ERROR(
+      ValidateTestbedState(testbed_, *ssh_client_, &curr_image_config));
   RETURN_IF_ERROR(ValidateComponents(&ComponentValidator::OnInit,
                                      component_validators_,
                                      curr_image_config.image_label, testbed_));
@@ -89,8 +90,8 @@ absl::Status NsfUpgradeTest::NsfUpgradeOrReboot(
 
   // Program all the flows.
   LOG(INFO) << "Programming flows before starting the traffic";
-  RETURN_IF_ERROR(
-      flow_programmer_->ProgramFlows(curr_image_config.p4_info, testbed_));
+  RETURN_IF_ERROR(flow_programmer_->ProgramFlows(curr_image_config.p4_info,
+                                                 testbed_, *ssh_client_));
   RETURN_IF_ERROR(ValidateComponents(&ComponentValidator::OnFlowProgram,
                                      component_validators_,
                                      curr_image_config.image_label, testbed_));
@@ -116,15 +117,15 @@ absl::Status NsfUpgradeTest::NsfUpgradeOrReboot(
   RETURN_IF_ERROR(ValidateComponents(&ComponentValidator::OnImageCopy,
                                      component_validators_,
                                      next_image_config.image_label, testbed_));
+  // TODO: Validate uptime and boot-type once they are supported.
 
   // Perform NSF Reboot.
   RETURN_IF_ERROR(NsfReboot(testbed_));
   RETURN_IF_ERROR(WaitForNsfReboot(testbed_, *ssh_client_));
 
   // Perform validations after reboot is completed.
-  RETURN_IF_ERROR(ValidateTestbedState(next_image_config.image_label, testbed_,
-                                       *ssh_client_,
-                                       next_image_config.gnmi_config));
+  RETURN_IF_ERROR(
+      ValidateTestbedState(testbed_, *ssh_client_, &next_image_config));
   RETURN_IF_ERROR(ValidateComponents(&ComponentValidator::OnNsfReboot,
                                      component_validators_,
                                      next_image_config.image_label, testbed_));
@@ -141,9 +142,8 @@ absl::Status NsfUpgradeTest::NsfUpgradeOrReboot(
 
   // Push the new config and validate.
   RETURN_IF_ERROR(PushConfig(next_image_config, testbed_, *ssh_client_));
-  RETURN_IF_ERROR(ValidateTestbedState(next_image_config.image_label, testbed_,
-                                       *ssh_client_,
-                                       next_image_config.gnmi_config));
+  RETURN_IF_ERROR(
+      ValidateTestbedState(testbed_, *ssh_client_, &next_image_config));
   RETURN_IF_ERROR(ValidateComponents(&ComponentValidator::OnConfigPush,
                                      component_validators_,
                                      next_image_config.image_label, testbed_));
@@ -156,15 +156,23 @@ absl::Status NsfUpgradeTest::NsfUpgradeOrReboot(
   LOG(INFO) << "Stopping the traffic";
   RETURN_IF_ERROR(traffic_helper_->StopTraffic(testbed_));
 
+  // TODO: For now, we validate traffic only after stopping
+  // traffic. Ideally we would want to validate traffic while injection is in
+  // progress to narrow down when the traffic loss occurred (i.e. before reboot,
+  // during reboot or after reconciliation). Although this is possible in OTG
+  // traffic generator, DVaaS traffic generator for now does not support traffic
+  // validation before stopping the traffic. This is a good-to-have feature and
+  // we will update the skeleton to validate traffic while injection is ongoing
+  // once this feature is available in DVaaS.
   LOG(INFO) << "Validating the traffic";
   RETURN_IF_ERROR(traffic_helper_->ValidateTraffic(testbed_, kErrorPercentage));
   RETURN_IF_ERROR(ValidateComponents(&ComponentValidator::OnStopTraffic,
                                      component_validators_,
                                      next_image_config.image_label, testbed_));
 
-  // Selectively clear flows (eg. not clearing nexthop entries for host
-  // testbeds).
-  LOG(INFO) << "Clearing the flows";
+  // TODO: Look into resetting the testbed state, including the
+  // flows on the SUT, in the same state as that before the test.
+  LOG(INFO) << "Clearing the flows from SUT";
   RETURN_IF_ERROR(flow_programmer_->ClearFlows(testbed_));
 
   RETURN_IF_ERROR(ValidateComponents(&ComponentValidator::OnFlowCleanup,