grpc 1.43.1 → 1.44.0.pre2

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

@@ -28,6 +28,7 @@
 #include "src/core/ext/xds/xds_api.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -35,6 +36,8 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
@@ -43,44 +46,14 @@ extern TraceFlag grpc_xds_client_refcount_trace;
 
 class XdsClient : public DualRefCounted<XdsClient> {
  public:
-  // Listener data watcher interface.  Implemented by callers.
-  class ListenerWatcherInterface : public RefCounted<ListenerWatcherInterface> {
+  // Resource watcher interface.  Implemented by callers.
+  // Note: Most callers will not use this API directly but rather via a
+  // resource-type-specific wrapper API provided by the relevant
+  // XdsResourceType implementation.
+  class ResourceWatcherInterface : public RefCounted<ResourceWatcherInterface> {
    public:
-    virtual void OnListenerChanged(XdsApi::LdsUpdate listener)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnError(grpc_error_handle error)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnResourceDoesNotExist()
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-  };
-
-  // RouteConfiguration data watcher interface.  Implemented by callers.
-  class RouteConfigWatcherInterface
-      : public RefCounted<RouteConfigWatcherInterface> {
-   public:
-    virtual void OnRouteConfigChanged(XdsApi::RdsUpdate route_config)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnError(grpc_error_handle error)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnResourceDoesNotExist()
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-  };
-
-  // Cluster data watcher interface.  Implemented by callers.
-  class ClusterWatcherInterface : public RefCounted<ClusterWatcherInterface> {
-   public:
-    virtual void OnClusterChanged(XdsApi::CdsUpdate cluster_data)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnError(grpc_error_handle error)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnResourceDoesNotExist()
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-  };
-
-  // Endpoint data watcher interface.  Implemented by callers.
-  class EndpointWatcherInterface : public RefCounted<EndpointWatcherInterface> {
-   public:
-    virtual void OnEndpointChanged(XdsApi::EdsUpdate update)
+    virtual void OnGenericResourceChanged(
+        const XdsResourceType::ResourceData* resource)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
     virtual void OnError(grpc_error_handle error)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
@@ -113,57 +86,31 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   void Orphan() override;
 
-  // Start and cancel listener data watch for a listener.
-  // The XdsClient takes ownership of the watcher, but the caller may
-  // keep a raw pointer to the watcher, which may be used only for
-  // cancellation.  (Because the caller does not own the watcher, the
-  // pointer must not be used for any other purpose.)
-  // If the caller is going to start a new watch after cancelling the
-  // old one, it should set delay_unsubscription to true.
-  void WatchListenerData(absl::string_view listener_name,
-                         RefCountedPtr<ListenerWatcherInterface> watcher);
-  void CancelListenerDataWatch(absl::string_view listener_name,
-                               ListenerWatcherInterface* watcher,
-                               bool delay_unsubscription = false);
-
-  // Start and cancel route config data watch for a listener.
-  // The XdsClient takes ownership of the watcher, but the caller may
-  // keep a raw pointer to the watcher, which may be used only for
-  // cancellation.  (Because the caller does not own the watcher, the
-  // pointer must not be used for any other purpose.)
-  // If the caller is going to start a new watch after cancelling the
-  // old one, it should set delay_unsubscription to true.
-  void WatchRouteConfigData(absl::string_view route_config_name,
-                            RefCountedPtr<RouteConfigWatcherInterface> watcher);
-  void CancelRouteConfigDataWatch(absl::string_view route_config_name,
-                                  RouteConfigWatcherInterface* watcher,
-                                  bool delay_unsubscription = false);
-
-  // Start and cancel cluster data watch for a cluster.
-  // The XdsClient takes ownership of the watcher, but the caller may
-  // keep a raw pointer to the watcher, which may be used only for
-  // cancellation.  (Because the caller does not own the watcher, the
-  // pointer must not be used for any other purpose.)
-  // If the caller is going to start a new watch after cancelling the
-  // old one, it should set delay_unsubscription to true.
-  void WatchClusterData(absl::string_view cluster_name,
-                        RefCountedPtr<ClusterWatcherInterface> watcher);
-  void CancelClusterDataWatch(absl::string_view cluster_name,
-                              ClusterWatcherInterface* watcher,
-                              bool delay_unsubscription = false);
-
-  // Start and cancel endpoint data watch for a cluster.
+  // Start and cancel watch for a resource.
+  //
   // The XdsClient takes ownership of the watcher, but the caller may
   // keep a raw pointer to the watcher, which may be used only for
   // cancellation.  (Because the caller does not own the watcher, the
   // pointer must not be used for any other purpose.)
   // If the caller is going to start a new watch after cancelling the
   // old one, it should set delay_unsubscription to true.
-  void WatchEndpointData(absl::string_view eds_service_name,
-                         RefCountedPtr<EndpointWatcherInterface> watcher);
-  void CancelEndpointDataWatch(absl::string_view eds_service_name,
-                               EndpointWatcherInterface* watcher,
-                               bool delay_unsubscription = false);
+  //
+  // The resource type object must be a global singleton, since the first
+  // time the XdsClient sees a particular resource type object, it will
+  // store the pointer to that object as the authoritative implementation for
+  // its type URLs.  The resource type object must outlive the XdsClient object,
+  // and it is illegal to start a subsequent watch for the same type URLs using
+  // a different resource type object.
+  //
+  // Note: Most callers will not use this API directly but rather via a
+  // resource-type-specific wrapper API provided by the relevant
+  // XdsResourceType implementation.
+  void WatchResource(const XdsResourceType* type, absl::string_view name,
+                     RefCountedPtr<ResourceWatcherInterface> watcher);
+  void CancelResourceWatch(const XdsResourceType* type,
+                           absl::string_view listener_name,
+                           ResourceWatcherInterface* watcher,
+                           bool delay_unsubscription = false);
 
   // Adds and removes drop stats for cluster_name and eds_service_name.
   RefCountedPtr<XdsClusterDropStats> AddClusterDropStats(
@@ -204,6 +151,22 @@ class XdsClient : public DualRefCounted<XdsClient> {
       const grpc_channel_args& args);
 
  private:
+  struct XdsResourceKey {
+    std::string id;
+    std::vector<URI::QueryParam> query_params;
+
+    bool operator<(const XdsResourceKey& other) const {
+      int c = id.compare(other.id);
+      if (c != 0) return c < 0;
+      return query_params < other.query_params;
+    }
+  };
+
+  struct XdsResourceName {
+    std::string authority;
+    XdsResourceKey key;
+  };
+
   // Contains a channel to the xds server and all the data related to the
   // channel.  Holds a ref to the xds client object.
   class ChannelState : public DualRefCounted<ChannelState> {
@@ -234,11 +197,11 @@ class XdsClient : public DualRefCounted<XdsClient> {
     void StartConnectivityWatchLocked();
     void CancelConnectivityWatchLocked();
 
-    void SubscribeLocked(const std::string& type_url,
-                         const XdsApi::ResourceName& name)
+    void SubscribeLocked(const XdsResourceType* type,
+                         const XdsResourceName& name)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
-    void UnsubscribeLocked(const std::string& type_url,
-                           const XdsApi::ResourceName& name,
+    void UnsubscribeLocked(const XdsResourceType* type,
+                           const XdsResourceName& name,
                            bool delay_unsubscription)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
@@ -260,55 +223,22 @@ class XdsClient : public DualRefCounted<XdsClient> {
     OrphanablePtr<RetryableCall<LrsCallState>> lrs_calld_;
 
     // Stores the most recent accepted resource version for each resource type.
-    std::map<std::string /*type*/, std::string /*version*/>
+    std::map<const XdsResourceType*, std::string /*version*/>
         resource_type_version_map_;
   };
 
-  struct ListenerState {
-    std::map<ListenerWatcherInterface*, RefCountedPtr<ListenerWatcherInterface>>
-        watchers;
-    // The latest data seen from LDS.
-    absl::optional<XdsApi::LdsUpdate> update;
-    XdsApi::ResourceMetadata meta;
-  };
-
-  struct RouteConfigState {
-    std::map<RouteConfigWatcherInterface*,
-             RefCountedPtr<RouteConfigWatcherInterface>>
-        watchers;
-    // The latest data seen from RDS.
-    absl::optional<XdsApi::RdsUpdate> update;
-    XdsApi::ResourceMetadata meta;
-  };
-
-  struct ClusterState {
-    std::map<ClusterWatcherInterface*, RefCountedPtr<ClusterWatcherInterface>>
-        watchers;
-    // The latest data seen from CDS.
-    absl::optional<XdsApi::CdsUpdate> update;
-    XdsApi::ResourceMetadata meta;
-  };
-
-  struct EndpointState {
-    std::map<EndpointWatcherInterface*, RefCountedPtr<EndpointWatcherInterface>>
+  struct ResourceState {
+    std::map<ResourceWatcherInterface*, RefCountedPtr<ResourceWatcherInterface>>
         watchers;
-    // The latest data seen from EDS.
-    absl::optional<XdsApi::EdsUpdate> update;
+    // The latest data seen for the resource.
+    std::unique_ptr<XdsResourceType::ResourceData> resource;
     XdsApi::ResourceMetadata meta;
   };
 
   struct AuthorityState {
     RefCountedPtr<ChannelState> channel_state;
-    std::map<std::string /*listener_name*/, ListenerState> listener_map;
-    std::map<std::string /*route_config_name*/, RouteConfigState>
-        route_config_map;
-    std::map<std::string /*cluster_name*/, ClusterState> cluster_map;
-    std::map<std::string /*eds_service_name*/, EndpointState> endpoint_map;
-
-    bool HasSubscribedResources() {
-      return !listener_map.empty() || !route_config_map.empty() ||
-             !cluster_map.empty() || !endpoint_map.empty();
-    }
+    std::map<const XdsResourceType*, std::map<XdsResourceKey, ResourceState>>
+        resource_map;
   };
 
   struct LoadReportState {
@@ -331,6 +261,19 @@ class XdsClient : public DualRefCounted<XdsClient> {
   void NotifyOnErrorLocked(grpc_error_handle error)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
+  void MaybeRegisterResourceTypeLocked(const XdsResourceType* resource_type)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Gets the type for resource_type, or null if the type is unknown.
+  const XdsResourceType* GetResourceTypeLocked(absl::string_view resource_type)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  static absl::StatusOr<XdsResourceName> ParseXdsResourceName(
+      absl::string_view name, const XdsResourceType* type);
+  static std::string ConstructFullXdsResourceName(
+      absl::string_view authority, absl::string_view resource_type,
+      const XdsResourceKey& key);
+
   XdsApi::ClusterLoadReportMap BuildLoadReportSnapshotLocked(
       bool send_all_clusters, const std::set<std::string>& clusters)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
@@ -348,6 +291,13 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   Mutex mu_;
 
+  // Stores resource type objects seen by type URL.
+  std::map<absl::string_view /*resource_type*/, const XdsResourceType*>
+      resource_types_ ABSL_GUARDED_BY(mu_);
+  std::map<absl::string_view /*v2_resource_type*/, const XdsResourceType*>
+      v2_resource_types_ ABSL_GUARDED_BY(mu_);
+  upb::SymbolTable symtab_ ABSL_GUARDED_BY(mu_);
+
   //  Map of existing xDS server channels.
   std::map<XdsBootstrap::XdsServer, ChannelState*> xds_server_channel_map_
       ABSL_GUARDED_BY(mu_);
@@ -363,15 +313,8 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   // Stores started watchers whose resource name was not parsed successfully,
   // waiting to be cancelled or reset in Orphan().
-  std::map<ListenerWatcherInterface*, RefCountedPtr<ListenerWatcherInterface>>
-      invalid_listener_watchers_ ABSL_GUARDED_BY(mu_);
-  std::map<RouteConfigWatcherInterface*,
-           RefCountedPtr<RouteConfigWatcherInterface>>
-      invalid_route_config_watchers_ ABSL_GUARDED_BY(mu_);
-  std::map<ClusterWatcherInterface*, RefCountedPtr<ClusterWatcherInterface>>
-      invalid_cluster_watchers_ ABSL_GUARDED_BY(mu_);
-  std::map<EndpointWatcherInterface*, RefCountedPtr<EndpointWatcherInterface>>
-      invalid_endpoint_watchers_ ABSL_GUARDED_BY(mu_);
+  std::map<ResourceWatcherInterface*, RefCountedPtr<ResourceWatcherInterface>>
+      invalid_watchers_ ABSL_GUARDED_BY(mu_);
 
   bool shutting_down_ ABSL_GUARDED_BY(mu_) = false;
 };