grpc 1.43.1 → 1.44.0.pre2

data/src/core/ext/xds/xds_listener.h

@@ -0,0 +1,220 @@
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_XDS_XDS_LISTENER_H
+#define GRPC_CORE_EXT_XDS_XDS_LISTENER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <array>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "envoy/config/listener/v3/listener.upbdefs.h"
+#include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
+
+#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/ext/xds/xds_resource_type_impl.h"
+#include "src/core/ext/xds/xds_route_config.h"
+
+namespace grpc_core {
+
+// TODO(roth): When we can use absl::variant<>, consider using that
+// here, to enforce the fact that only one of the two fields can be set.
+struct XdsListenerResource {
+  struct DownstreamTlsContext {
+    CommonTlsContext common_tls_context;
+    bool require_client_certificate = false;
+
+    bool operator==(const DownstreamTlsContext& other) const {
+      return common_tls_context == other.common_tls_context &&
+             require_client_certificate == other.require_client_certificate;
+    }
+
+    std::string ToString() const;
+    bool Empty() const;
+  };
+
+  enum class ListenerType {
+    kTcpListener = 0,
+    kHttpApiListener,
+  } type;
+
+  struct HttpConnectionManager {
+    // The name to use in the RDS request.
+    std::string route_config_name;
+    // Storing the Http Connection Manager Common Http Protocol Option
+    // max_stream_duration
+    Duration http_max_stream_duration;
+    // The RouteConfiguration to use for this listener.
+    // Present only if it is inlined in the LDS response.
+    absl::optional<XdsRouteConfigResource> rds_update;
+
+    struct HttpFilter {
+      std::string name;
+      XdsHttpFilterImpl::FilterConfig config;
+
+      bool operator==(const HttpFilter& other) const {
+        return name == other.name && config == other.config;
+      }
+
+      std::string ToString() const;
+    };
+    std::vector<HttpFilter> http_filters;
+
+    bool operator==(const HttpConnectionManager& other) const {
+      return route_config_name == other.route_config_name &&
+             http_max_stream_duration == other.http_max_stream_duration &&
+             rds_update == other.rds_update &&
+             http_filters == other.http_filters;
+    }
+
+    std::string ToString() const;
+  };
+
+  // Populated for type=kHttpApiListener.
+  HttpConnectionManager http_connection_manager;
+
+  // Populated for type=kTcpListener.
+  // host:port listening_address set when type is kTcpListener
+  std::string address;
+
+  struct FilterChainData {
+    DownstreamTlsContext downstream_tls_context;
+    // This is in principle the filter list.
+    // We currently require exactly one filter, which is the HCM.
+    HttpConnectionManager http_connection_manager;
+
+    bool operator==(const FilterChainData& other) const {
+      return downstream_tls_context == other.downstream_tls_context &&
+             http_connection_manager == other.http_connection_manager;
+    }
+
+    std::string ToString() const;
+  };
+
+  // A multi-level map used to determine which filter chain to use for a given
+  // incoming connection. Determining the right filter chain for a given
+  // connection checks the following properties, in order:
+  // - destination port (never matched, so not present in map)
+  // - destination IP address
+  // - server name (never matched, so not present in map)
+  // - transport protocol (allows only "raw_buffer" or unset, prefers the
+  //   former, so only one of those two types is present in map)
+  // - application protocol (never matched, so not present in map)
+  // - connection source type (any, local or external)
+  // - source IP address
+  // - source port
+  // https://www.envoyproxy.io/docs/envoy/latest/api-v3/config/listener/v3/listener_components.proto#config-listener-v3-filterchainmatch
+  // for more details
+  struct FilterChainMap {
+    struct FilterChainDataSharedPtr {
+      std::shared_ptr<FilterChainData> data;
+      bool operator==(const FilterChainDataSharedPtr& other) const {
+        return *data == *other.data;
+      }
+    };
+    struct CidrRange {
+      grpc_resolved_address address;
+      uint32_t prefix_len;
+
+      bool operator==(const CidrRange& other) const {
+        return memcmp(&address, &other.address, sizeof(address)) == 0 &&
+               prefix_len == other.prefix_len;
+      }
+
+      std::string ToString() const;
+    };
+    using SourcePortsMap = std::map<uint16_t, FilterChainDataSharedPtr>;
+    struct SourceIp {
+      absl::optional<CidrRange> prefix_range;
+      SourcePortsMap ports_map;
+
+      bool operator==(const SourceIp& other) const {
+        return prefix_range == other.prefix_range &&
+               ports_map == other.ports_map;
+      }
+    };
+    using SourceIpVector = std::vector<SourceIp>;
+    enum class ConnectionSourceType { kAny = 0, kSameIpOrLoopback, kExternal };
+    using ConnectionSourceTypesArray = std::array<SourceIpVector, 3>;
+    struct DestinationIp {
+      absl::optional<CidrRange> prefix_range;
+      // We always fail match on server name, so those filter chains are not
+      // included here.
+      ConnectionSourceTypesArray source_types_array;
+
+      bool operator==(const DestinationIp& other) const {
+        return prefix_range == other.prefix_range &&
+               source_types_array == other.source_types_array;
+      }
+    };
+    // We always fail match on destination ports map
+    using DestinationIpVector = std::vector<DestinationIp>;
+    DestinationIpVector destination_ip_vector;
+
+    bool operator==(const FilterChainMap& other) const {
+      return destination_ip_vector == other.destination_ip_vector;
+    }
+
+    std::string ToString() const;
+  } filter_chain_map;
+
+  absl::optional<FilterChainData> default_filter_chain;
+
+  bool operator==(const XdsListenerResource& other) const {
+    return http_connection_manager == other.http_connection_manager &&
+           address == other.address &&
+           filter_chain_map == other.filter_chain_map &&
+           default_filter_chain == other.default_filter_chain;
+  }
+
+  std::string ToString() const;
+};
+
+class XdsListenerResourceType
+    : public XdsResourceTypeImpl<XdsListenerResourceType, XdsListenerResource> {
+ public:
+  absl::string_view type_url() const override {
+    return "envoy.config.listener.v3.Listener";
+  }
+  absl::string_view v2_type_url() const override {
+    return "envoy.api.v2.Listener";
+  }
+
+  absl::StatusOr<DecodeResult> Decode(const XdsEncodingContext& context,
+                                      absl::string_view serialized_resource,
+                                      bool is_v2) const override;
+
+  bool AllResourcesRequiredInSotW() const override { return true; }
+
+  void InitUpbSymtab(upb_symtab* symtab) const override {
+    envoy_config_listener_v3_Listener_getmsgdef(symtab);
+    envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
+        symtab);
+    XdsHttpFilterRegistry::PopulateSymtab(symtab);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_LISTENER_H

data/src/core/ext/{transport/chttp2/transport/hpack_utils.h → xds/xds_resource_type.cc}

@@ -1,3 +1,4 @@
+//
 // Copyright 2021 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -11,20 +12,22 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
-#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H
+//
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/transport/metadata.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 
 namespace grpc_core {
 
-// Return the size occupied by some metadata in the HPACK table.
-size_t MetadataSizeInHPackTable(grpc_mdelem elem,
-                                bool use_true_binary_metadata);
+bool XdsResourceType::IsType(absl::string_view resource_type,
+                             bool* is_v2) const {
+  if (resource_type == type_url()) return true;
+  if (resource_type == v2_type_url()) {
+    if (is_v2 != nullptr) *is_v2 = true;
+    return true;
+  }
+  return false;
+}
 
 }  // namespace grpc_core
-
-#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H

data/src/core/ext/xds/xds_resource_type.h

@@ -0,0 +1,98 @@
+//
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/ext/xds/upb_utils.h"
+
+#ifndef GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
+#define GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
+
+namespace grpc_core {
+
+// Interface for an xDS resource type.
+// Used to inject type-specific logic into XdsClient.
+class XdsResourceType {
+ public:
+  // A base type for resource data.
+  // Subclasses will extend this, and their DecodeResults will be
+  // downcastable to their extended type.
+  struct ResourceData {
+    virtual ~ResourceData() = default;
+  };
+
+  // Result returned by Decode().
+  struct DecodeResult {
+    std::string name;
+    absl::StatusOr<std::unique_ptr<ResourceData>> resource;
+  };
+
+  virtual ~XdsResourceType() = default;
+
+  // Returns v3 resource type.
+  virtual absl::string_view type_url() const = 0;
+
+  // Returns v2 resource type.
+  virtual absl::string_view v2_type_url() const = 0;
+
+  // Decodes and validates a serialized resource proto.
+  // If the resource fails protobuf deserialization, returns non-OK status.
+  // If the deserialized resource fails validation, returns a DecodeResult
+  // whose resource field is set to a non-OK status.
+  // Otherwise, returns a DecodeResult with a valid resource.
+  virtual absl::StatusOr<DecodeResult> Decode(
+      const XdsEncodingContext& context, absl::string_view serialized_resource,
+      bool is_v2) const = 0;
+
+  // Returns true if r1 and r2 are equal.
+  // Must be invoked only on resources returned by this object's Decode()
+  // method.
+  virtual bool ResourcesEqual(const ResourceData* r1,
+                              const ResourceData* r2) const = 0;
+
+  // Returns a copy of resource.
+  // Must be invoked only on resources returned by this object's Decode()
+  // method.
+  virtual std::unique_ptr<ResourceData> CopyResource(
+      const ResourceData* resource) const = 0;
+
+  // Indicates whether the resource type requires that all resources must
+  // be present in every SotW response from the server.  If true, a
+  // response that does not include a previously seen resource will be
+  // interpreted as a deletion of that resource.
+  virtual bool AllResourcesRequiredInSotW() const { return false; }
+
+  // Populate upb symtab with xDS proto messages that we want to print
+  // properly in logs.
+  // Note: This won't actually work properly until upb adds support for
+  // Any fields in textproto printing (internal b/178821188).
+  virtual void InitUpbSymtab(upb_symtab* symtab) const = 0;
+
+  // Convenience method for checking if resource_type matches this type.
+  // Checks against both type_url() and v2_type_url().
+  // If is_v2 is non-null, it will be set to true if matching v2_type_url().
+  bool IsType(absl::string_view resource_type, bool* is_v2) const;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H

data/src/core/ext/xds/xds_resource_type_impl.h

@@ -0,0 +1,87 @@
+//
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_resource_type.h"
+
+#ifndef GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_IMPL_H
+#define GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_IMPL_H
+
+namespace grpc_core {
+
+// Base class for XdsResourceType implementations.
+// Handles all down-casting logic for a particular resource type struct.
+template <typename Subclass, typename ResourceTypeStruct>
+class XdsResourceTypeImpl : public XdsResourceType {
+ public:
+  struct ResourceDataSubclass : public ResourceData {
+    ResourceTypeStruct resource;
+  };
+
+  // XdsClient watcher that handles down-casting.
+  class WatcherInterface : public XdsClient::ResourceWatcherInterface {
+   public:
+    virtual void OnResourceChanged(ResourceTypeStruct listener) = 0;
+
+   private:
+    // Get result from XdsClient generic watcher interface, perform
+    // down-casting, and invoke the caller's OnListenerChanged() method.
+    void OnGenericResourceChanged(
+        const XdsResourceType::ResourceData* resource) override {
+      OnResourceChanged(
+          static_cast<const ResourceDataSubclass*>(resource)->resource);
+    }
+  };
+
+  static const Subclass* Get() {
+    static const Subclass* g_instance = new Subclass();
+    return g_instance;
+  }
+
+  // Convenient wrappers around XdsClient generic watcher API that provide
+  // type-safety.
+  static void StartWatch(XdsClient* xds_client, absl::string_view resource_name,
+                         RefCountedPtr<WatcherInterface> watcher) {
+    xds_client->WatchResource(Get(), resource_name, std::move(watcher));
+  }
+  static void CancelWatch(XdsClient* xds_client,
+                          absl::string_view resource_name,
+                          WatcherInterface* watcher,
+                          bool delay_unsubscription = false) {
+    xds_client->CancelResourceWatch(Get(), resource_name, watcher,
+                                    delay_unsubscription);
+  }
+
+  bool ResourcesEqual(const ResourceData* r1,
+                      const ResourceData* r2) const override {
+    return static_cast<const ResourceDataSubclass*>(r1)->resource ==
+           static_cast<const ResourceDataSubclass*>(r2)->resource;
+  }
+
+  std::unique_ptr<ResourceData> CopyResource(
+      const ResourceData* resource) const override {
+    auto* resource_copy = new ResourceDataSubclass();
+    resource_copy->resource =
+        static_cast<const ResourceDataSubclass*>(resource)->resource;
+    return std::unique_ptr<ResourceData>(resource_copy);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_IMPL_H