grid: Add a new class for tracking alternate protocols for a connection to an origin. (#16127)

grid: Add a new class for tracking alternate protocols for a connection to an origin.

Create a new AlternateProtocols class which tracks the list of alternate
protocols which can be used to make connections to origins.

Risk Level: Low
Testing: New Unit tests
Docs Changes: N/A
Release Notes: N/A
Platform Specific Features: N/A

Signed-off-by: Ryan Hamilton <[email protected]>

Author: RyanTheOptimist

source/common/http/BUILD

@@ -149,6 +149,15 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "alternate_protocols",
+    srcs = ["alternate_protocols.cc"],
+    hdrs = ["alternate_protocols.h"],
+    deps = [
+        "//include/envoy/common:time_interface",
+    ],
+)
+
 envoy_cc_library(
     name = "conn_pool_grid",
     srcs = ["conn_pool_grid.cc"],

source/common/http/alternate_protocols.cc

@@ -0,0 +1,46 @@
+#include "common/http/alternate_protocols.h"
+
+namespace Envoy {
+namespace Http {
+
+AlternateProtocols::AlternateProtocol::AlternateProtocol(absl::string_view alpn,
+                                                         absl::string_view hostname, int port)
+    : alpn_(alpn), hostname_(hostname), port_(port) {}
+
+AlternateProtocols::Origin::Origin(absl::string_view scheme, absl::string_view hostname, int port)
+    : scheme_(scheme), hostname_(hostname), port_(port) {}
+
+AlternateProtocols::AlternateProtocols(TimeSource& time_source) : time_source_(time_source) {}
+
+void AlternateProtocols::setAlternatives(const Origin& origin,
+                                         const std::vector<AlternateProtocol>& protocols,
+                                         const MonotonicTime& expiration) {
+  Entry& entry = protocols_[origin];
+  if (entry.protocols_ != protocols) {
+    entry.protocols_ = protocols;
+  }
+  if (entry.expiration_ != expiration) {
+    entry.expiration_ = expiration;
+  }
+}
+
+OptRef<const std::vector<AlternateProtocols::AlternateProtocol>>
+AlternateProtocols::findAlternatives(const Origin& origin) {
+  auto entry_it = protocols_.find(origin);
+  if (entry_it == protocols_.end()) {
+    return makeOptRefFromPtr<const std::vector<AlternateProtocols::AlternateProtocol>>(nullptr);
+  }
+
+  const Entry& entry = entry_it->second;
+  if (time_source_.monotonicTime() > entry.expiration_) {
+    // Expire the entry.
+    protocols_.erase(entry_it);
+    return makeOptRefFromPtr<const std::vector<AlternateProtocols::AlternateProtocol>>(nullptr);
+  }
+  return makeOptRef(entry.protocols_);
+}
+
+size_t AlternateProtocols::size() const { return protocols_.size(); }
+
+} // namespace Http
+} // namespace Envoy

source/common/http/alternate_protocols.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "envoy/common/optref.h"
+#include "envoy/common/time.h"
+
+#include "absl/strings/string_view.h"
+
+namespace Envoy {
+namespace Http {
+
+// Tracks alternate protocols that can be used to make an HTTP connection to an origin server.
+// See https://tools.ietf.org/html/rfc7838 for HTTP Alternate Services and
+// https://datatracker.ietf.org/doc/html/draft-ietf-dnsop-svcb-https-04 for the
+// "HTTPS" DNS resource record.
+class AlternateProtocols {
+public:
+  // Represents an HTTP origin to be connected too.
+  struct Origin {
+  public:
+    Origin(absl::string_view scheme, absl::string_view hostname, int port);
+
+    bool operator==(const Origin& other) const {
+      return std::tie(scheme_, hostname_, port_) ==
+             std::tie(other.scheme_, other.hostname_, other.port_);
+    }
+
+    bool operator!=(const Origin& other) const { return !this->operator==(other); }
+
+    bool operator<(const Origin& other) const {
+      return std::tie(scheme_, hostname_, port_) <
+             std::tie(other.scheme_, other.hostname_, other.port_);
+    }
+
+    bool operator>(const Origin& other) const {
+      return std::tie(scheme_, hostname_, port_) >
+             std::tie(other.scheme_, other.hostname_, other.port_);
+    }
+
+    bool operator<=(const Origin& other) const {
+      return std::tie(scheme_, hostname_, port_) <=
+             std::tie(other.scheme_, other.hostname_, other.port_);
+    }
+
+    bool operator>=(const Origin& other) const {
+      return std::tie(scheme_, hostname_, port_) >=
+             std::tie(other.scheme_, other.hostname_, other.port_);
+    }
+
+    std::string scheme_;
+    std::string hostname_;
+    int port_{};
+  };
+
+  // Represents an alternative protocol that can be used to connect to an origin.
+  struct AlternateProtocol {
+  public:
+    AlternateProtocol(absl::string_view alpn, absl::string_view hostname, int port);
+
+    bool operator==(const AlternateProtocol& other) const {
+      return std::tie(alpn_, hostname_, port_) ==
+             std::tie(other.alpn_, other.hostname_, other.port_);
+    }
+
+    bool operator!=(const AlternateProtocol& other) const { return !this->operator==(other); }
+
+    std::string alpn_;
+    std::string hostname_;
+    int port_;
+  };
+
+  explicit AlternateProtocols(TimeSource& time_source);
+
+  // Sets the possible alternative protocols which can be used to connect to the
+  // specified origin. Expires after the specified expiration time.
+  void setAlternatives(const Origin& origin, const std::vector<AlternateProtocol>& protocols,
+                       const MonotonicTime& expiration);
+
+  // Returns the possible alternative protocols which can be used to connect to the
+  // specified origin, or nullptr if not alternatives are found. The returned pointer
+  // is owned by the AlternateProtocols and is valid until the next operation on
+  // AlternateProtocols.
+  OptRef<const std::vector<AlternateProtocol>> findAlternatives(const Origin& origin);
+
+  // Returns the number of entries in the map.
+  size_t size() const;
+
+private:
+  struct Entry {
+    std::vector<AlternateProtocol> protocols_;
+    MonotonicTime expiration_;
+  };
+
+  // Time source used to check expiration of entries.
+  TimeSource& time_source_;
+
+  // Map from hostname to list of alternate protocols.
+  // TODO(RyanTheOptimist): Add a limit to the size of this map and evict based on usage.
+  std::map<Origin, Entry> protocols_;
+};
+
+} // namespace Http
+} // namespace Envoy

test/common/http/BUILD

@@ -440,6 +440,17 @@ envoy_cc_test(
     ]),
 )
 
+envoy_cc_test(
+    name = "alternate_protocols_test",
+    srcs = ["alternate_protocols_test.cc"],
+    deps = [
+        ":common_lib",
+        "//source/common/http:alternate_protocols",
+        "//test/mocks:common_lib",
+        "//test/test_common:simulated_time_system_lib",
+    ],
+)
+
 envoy_proto_library(
     name = "path_utility_fuzz_proto",
     srcs = ["path_utility_fuzz.proto"],

test/common/http/alternate_protocols_test.cc

@@ -0,0 +1,88 @@
+#include "common/http/alternate_protocols.h"
+
+#include "test/test_common/simulated_time_system.h"
+
+#include "gtest/gtest.h"
+
+namespace Envoy {
+namespace Http {
+
+namespace {
+class AlternateProtocolsTest : public testing::Test, public Event::TestUsingSimulatedTime {
+public:
+  AlternateProtocolsTest() : protocols_(simTime()) {}
+
+  AlternateProtocols protocols_;
+  const std::string hostname1_ = "hostname1";
+  const std::string hostname2_ = "hostname2";
+  const int port1_ = 1;
+  const int port2_ = 2;
+  const std::string https_ = "https";
+  const std::string http_ = "http";
+
+  const std::string alpn1_ = "alpn1";
+  const std::string alpn2_ = "alpn2";
+
+  const AlternateProtocols::Origin origin1_ = {https_, hostname1_, port1_};
+  const AlternateProtocols::Origin origin2_ = {https_, hostname2_, port2_};
+
+  const AlternateProtocols::AlternateProtocol protocol1_ = {alpn1_, hostname1_, port1_};
+  const AlternateProtocols::AlternateProtocol protocol2_ = {alpn2_, hostname2_, port2_};
+
+  const std::vector<AlternateProtocols::AlternateProtocol> protocols1_ = {protocol1_};
+  const std::vector<AlternateProtocols::AlternateProtocol> protocols2_ = {protocol2_};
+
+  const MonotonicTime expiration1_ = simTime().monotonicTime() + Seconds(5);
+  const MonotonicTime expiration2_ = simTime().monotonicTime() + Seconds(10);
+};
+
+TEST_F(AlternateProtocolsTest, Init) { EXPECT_EQ(0, protocols_.size()); }
+
+TEST_F(AlternateProtocolsTest, SetAlternatives) {
+  EXPECT_EQ(0, protocols_.size());
+  protocols_.setAlternatives(origin1_, protocols1_, expiration1_);
+  EXPECT_EQ(1, protocols_.size());
+}
+
+TEST_F(AlternateProtocolsTest, FindAlternatives) {
+  protocols_.setAlternatives(origin1_, protocols1_, expiration1_);
+  OptRef<const std::vector<AlternateProtocols::AlternateProtocol>> protocols =
+      protocols_.findAlternatives(origin1_);
+  ASSERT_TRUE(protocols.has_value());
+  EXPECT_EQ(protocols1_, protocols.ref());
+}
+
+TEST_F(AlternateProtocolsTest, FindAlternativesAfterReplacement) {
+  protocols_.setAlternatives(origin1_, protocols1_, expiration1_);
+  protocols_.setAlternatives(origin1_, protocols2_, expiration2_);
+  OptRef<const std::vector<AlternateProtocols::AlternateProtocol>> protocols =
+      protocols_.findAlternatives(origin1_);
+  ASSERT_TRUE(protocols.has_value());
+  EXPECT_EQ(protocols2_, protocols.ref());
+  EXPECT_NE(protocols1_, protocols.ref());
+}
+
+TEST_F(AlternateProtocolsTest, FindAlternativesForMultipleOrigins) {
+  protocols_.setAlternatives(origin1_, protocols1_, expiration1_);
+  protocols_.setAlternatives(origin2_, protocols2_, expiration2_);
+  OptRef<const std::vector<AlternateProtocols::AlternateProtocol>> protocols =
+      protocols_.findAlternatives(origin1_);
+  ASSERT_TRUE(protocols.has_value());
+  EXPECT_EQ(protocols1_, protocols.ref());
+
+  protocols = protocols_.findAlternatives(origin2_);
+  EXPECT_EQ(protocols2_, protocols.ref());
+}
+
+TEST_F(AlternateProtocolsTest, FindAlternativesAfterExpiration) {
+  protocols_.setAlternatives(origin1_, protocols1_, expiration1_);
+  simTime().setMonotonicTime(expiration1_ + Seconds(1));
+  OptRef<const std::vector<AlternateProtocols::AlternateProtocol>> protocols =
+      protocols_.findAlternatives(origin1_);
+  ASSERT_FALSE(protocols.has_value());
+  EXPECT_EQ(0, protocols_.size());
+}
+
+} // namespace
+} // namespace Http
+} // namespace Envoy