grpc 1.24.0 → 1.25.0.pre1

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

@@ -0,0 +1,221 @@
+//
+// Copyright 2019 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_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/service_config.h"
+#include "src/core/ext/filters/client_channel/xds/xds_api.h"
+#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
+#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
+#include "src/core/lib/gprpp/map.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/set.h"
+#include "src/core/lib/gprpp/string_view.h"
+#include "src/core/lib/iomgr/combiner.h"
+
+namespace grpc_core {
+
+extern TraceFlag xds_client_trace;
+
+class XdsClient : public InternallyRefCounted<XdsClient> {
+ public:
+  // Service config watcher interface.  Implemented by callers.
+  class ServiceConfigWatcherInterface {
+   public:
+    virtual ~ServiceConfigWatcherInterface() = default;
+
+    virtual void OnServiceConfigChanged(
+        RefCountedPtr<ServiceConfig> service_config) = 0;
+
+    virtual void OnError(grpc_error* error) = 0;
+  };
+
+  // Cluster data watcher interface.  Implemented by callers.
+  class ClusterWatcherInterface {
+   public:
+    virtual ~ClusterWatcherInterface() = default;
+
+    virtual void OnClusterChanged(CdsUpdate cluster_data) = 0;
+
+    virtual void OnError(grpc_error* error) = 0;
+  };
+
+  // Endpoint data watcher interface.  Implemented by callers.
+  class EndpointWatcherInterface {
+   public:
+    virtual ~EndpointWatcherInterface() = default;
+
+    virtual void OnEndpointChanged(EdsUpdate update) = 0;
+
+    virtual void OnError(grpc_error* error) = 0;
+  };
+
+  // If *error is not GRPC_ERROR_NONE after construction, then there was
+  // an error initializing the client.
+  XdsClient(Combiner* combiner, grpc_pollset_set* interested_parties,
+            StringView server_name,
+            UniquePtr<ServiceConfigWatcherInterface> watcher,
+            const grpc_channel_args& channel_args, grpc_error** error);
+  ~XdsClient();
+
+  void Orphan() override;
+
+  // 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.)
+  void WatchClusterData(StringView cluster,
+                        UniquePtr<ClusterWatcherInterface> watcher);
+  void CancelClusterDataWatch(StringView cluster,
+                              ClusterWatcherInterface* watcher);
+
+  // Start and cancel endpoint 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.)
+  void WatchEndpointData(StringView cluster,
+                         UniquePtr<EndpointWatcherInterface> watcher);
+  void CancelEndpointDataWatch(StringView cluster,
+                               EndpointWatcherInterface* watcher);
+
+  // Adds and removes client stats for cluster.
+  void AddClientStats(StringView cluster, XdsClientStats* client_stats);
+  void RemoveClientStats(StringView cluster, XdsClientStats* client_stats);
+
+  // Resets connection backoff state.
+  void ResetBackoff();
+
+  // Helpers for encoding the XdsClient object in channel args.
+  grpc_arg MakeChannelArg() const;
+  static RefCountedPtr<XdsClient> GetFromChannelArgs(
+      const grpc_channel_args& args);
+
+ private:
+  // Contains a channel to the xds server and all the data related to the
+  // channel.  Holds a ref to the xds client object.
+  // TODO(roth): This is separate from the XdsClient object because it was
+  // originally designed to be able to swap itself out in case the
+  // balancer name changed.  Now that the balancer name is going to be
+  // coming from the bootstrap file, we don't really need this level of
+  // indirection unless we decide to support watching the bootstrap file
+  // for changes.  At some point, if we decide that we're never going to
+  // need to do that, then we can eliminate this class and move its
+  // contents directly into the XdsClient class.
+  class ChannelState : public InternallyRefCounted<ChannelState> {
+   public:
+    template <typename T>
+    class RetryableCall;
+
+    class AdsCallState;
+    class LrsCallState;
+
+    ChannelState(RefCountedPtr<XdsClient> xds_client,
+                 const grpc_channel_args& args);
+    ~ChannelState();
+
+    void Orphan() override;
+
+    grpc_channel* channel() const { return channel_; }
+    XdsClient* xds_client() const { return xds_client_.get(); }
+    AdsCallState* ads_calld() const;
+    LrsCallState* lrs_calld() const;
+
+    void MaybeStartAdsCall();
+    void StopAdsCall();
+
+    void MaybeStartLrsCall();
+    void StopLrsCall();
+
+    bool HasActiveAdsCall() const;
+
+    void StartConnectivityWatchLocked();
+    void CancelConnectivityWatchLocked();
+
+   private:
+    class StateWatcher;
+
+    // The owning xds client.
+    RefCountedPtr<XdsClient> xds_client_;
+
+    // The channel and its status.
+    grpc_channel* channel_;
+    bool shutting_down_ = false;
+    StateWatcher* watcher_ = nullptr;
+
+    // The retryable XDS calls.
+    OrphanablePtr<RetryableCall<AdsCallState>> ads_calld_;
+    OrphanablePtr<RetryableCall<LrsCallState>> lrs_calld_;
+  };
+
+  struct ClusterState {
+    Map<ClusterWatcherInterface*, UniquePtr<ClusterWatcherInterface>>
+        cluster_watchers;
+    Map<EndpointWatcherInterface*, UniquePtr<EndpointWatcherInterface>>
+        endpoint_watchers;
+    Set<XdsClientStats*> client_stats;
+    // The latest data seen from EDS.
+    EdsUpdate eds_update;
+  };
+
+  // Sends an error notification to all watchers.
+  void NotifyOnError(grpc_error* error);
+
+  // TODO(juanlishen): Once we implement LDS support, this can be a
+  // normal method instead of a closure callback.
+  static void NotifyOnServiceConfig(void* arg, grpc_error* error);
+
+  // Channel arg vtable functions.
+  static void* ChannelArgCopy(void* p);
+  static void ChannelArgDestroy(void* p);
+  static int ChannelArgCmp(void* p, void* q);
+
+  static const grpc_arg_pointer_vtable kXdsClientVtable;
+
+  UniquePtr<char> build_version_;
+
+  Combiner* combiner_;
+  grpc_pollset_set* interested_parties_;
+
+  UniquePtr<XdsBootstrap> bootstrap_;
+
+  UniquePtr<char> server_name_;
+  UniquePtr<ServiceConfigWatcherInterface> service_config_watcher_;
+  // TODO(juanlishen): Once we implement LDS support, this will no
+  // longer be needed.
+  grpc_closure service_config_notify_;
+
+  // The channel for communicating with the xds server.
+  OrphanablePtr<ChannelState> chand_;
+
+  // TODO(roth): When we need support for multiple clusters, replace
+  // cluster_state_ with a map keyed by cluster name.
+  ClusterState cluster_state_;
+  // Map<StringView /*cluster*/, ClusterState, StringLess> clusters_;
+
+  bool shutting_down_ = false;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H */

data/src/core/ext/filters/client_channel/{lb_policy/xds → xds}/xds_client_stats.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_client_stats.h"
+#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
 
 #include <grpc/support/atm.h>
 #include <grpc/support/string_util.h>
@@ -143,15 +143,11 @@ XdsClientStats::Snapshot XdsClientStats::GetSnapshotAndReset() {
   }
   {
     MutexLock lock(&dropped_requests_mu_);
-#if GRPC_USE_CPP_STD_LIB
     // This is a workaround for the case where some compilers cannot build
     // move-assignment of map with non-copyable but movable key.
     // https://stackoverflow.com/questions/36475497
     std::swap(snapshot.dropped_requests, dropped_requests_);
     dropped_requests_.clear();
-#else
-    snapshot.dropped_requests = std::move(dropped_requests_);
-#endif
   }
   return snapshot;
 }

data/src/core/ext/filters/client_channel/{lb_policy/xds → xds}/xds_client_stats.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_CLIENT_STATS_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_CLIENT_STATS_H
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_STATS_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_STATS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -226,5 +226,4 @@ class XdsClientStats {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_CLIENT_STATS_H \
-        */
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_STATS_H */

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -233,14 +233,14 @@ void grpc_deadline_state_client_start_transport_stream_op_batch(
 //
 
 // Constructor for channel_data.  Used for both client and server filters.
-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* deadline_init_channel_elem(grpc_channel_element* elem,
+                                              grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
   return GRPC_ERROR_NONE;
 }
 
 // Destructor for channel_data.  Used for both client and server filters.
-static void destroy_channel_elem(grpc_channel_element* elem) {}
+static void deadline_destroy_channel_elem(grpc_channel_element* elem) {}
 
 // Call data used for both client and server filter.
 typedef struct base_call_data {
@@ -260,24 +260,24 @@ typedef struct server_call_data {
 } server_call_data;
 
 // Constructor for call_data.  Used for both client and server filters.
-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* deadline_init_call_elem(grpc_call_element* elem,
+                                           const grpc_call_element_args* args) {
   new (elem->call_data) grpc_deadline_state(
       elem, args->call_stack, args->call_combiner, args->deadline);
   return GRPC_ERROR_NONE;
 }
 
 // Destructor for call_data.  Used for both client and server filters.
-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {
+static void deadline_destroy_call_elem(grpc_call_element* elem,
+                                       const grpc_call_final_info* final_info,
+                                       grpc_closure* ignored) {
   grpc_deadline_state* deadline_state =
       static_cast<grpc_deadline_state*>(elem->call_data);
   deadline_state->~grpc_deadline_state();
 }
 
 // Method for starting a call op for client filter.
-static void client_start_transport_stream_op_batch(
+static void deadline_client_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   grpc_deadline_state_client_start_transport_stream_op_batch(elem, op);
   // Chain to next filter.
@@ -295,7 +295,7 @@ static void recv_initial_metadata_ready(void* arg, grpc_error* error) {
 }
 
 // Method for starting a call op for server filter.
-static void server_start_transport_stream_op_batch(
+static void deadline_server_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
   if (op->cancel_stream) {
@@ -329,29 +329,29 @@ static void server_start_transport_stream_op_batch(
 }
 
 const grpc_channel_filter grpc_client_deadline_filter = {
-    client_start_transport_stream_op_batch,
+    deadline_client_start_transport_stream_op_batch,
     grpc_channel_next_op,
     sizeof(base_call_data),
-    init_call_elem,
+    deadline_init_call_elem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    destroy_call_elem,
+    deadline_destroy_call_elem,
     0,  // sizeof(channel_data)
-    init_channel_elem,
-    destroy_channel_elem,
+    deadline_init_channel_elem,
+    deadline_destroy_channel_elem,
     grpc_channel_next_get_info,
     "deadline",
 };
 
 const grpc_channel_filter grpc_server_deadline_filter = {
-    server_start_transport_stream_op_batch,
+    deadline_server_start_transport_stream_op_batch,
     grpc_channel_next_op,
     sizeof(server_call_data),
-    init_call_elem,
+    deadline_init_call_elem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    destroy_call_elem,
+    deadline_destroy_call_elem,
     0,  // sizeof(channel_data)
-    init_channel_elem,
-    destroy_channel_elem,
+    deadline_init_channel_elem,
+    deadline_destroy_channel_elem,
     grpc_channel_next_get_info,
     "deadline",
 };

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -340,11 +340,11 @@ static void remove_if_present(grpc_metadata_batch* batch,
   }
 }
 
-static void hc_start_transport_stream_op_batch(
+static void http_client_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* channeld = static_cast<channel_data*>(elem->channel_data);
-  GPR_TIMER_SCOPE("hc_start_transport_stream_op_batch", 0);
+  GPR_TIMER_SCOPE("http_client_start_transport_stream_op_batch", 0);
 
   if (batch->recv_initial_metadata) {
     /* substitute our callback for the higher callback */
@@ -465,16 +465,16 @@ done:
 }
 
 /* Constructor for call_data */
-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* http_client_init_call_elem(
+    grpc_call_element* elem, const grpc_call_element_args* args) {
   new (elem->call_data) call_data(elem, *args);
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {
+static void http_client_destroy_call_elem(
+    grpc_call_element* elem, const grpc_call_final_info* final_info,
+    grpc_closure* ignored) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->~call_data();
 }
@@ -566,8 +566,8 @@ static grpc_core::ManagedMemorySlice user_agent_from_args(
 }
 
 /* Constructor for channel_data */
-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* http_client_init_channel_elem(
+    grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(!args->is_last);
   GPR_ASSERT(args->optional_transport != nullptr);
@@ -582,20 +582,20 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 }
 
 /* Destructor for channel data */
-static void destroy_channel_elem(grpc_channel_element* elem) {
+static void http_client_destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GRPC_MDELEM_UNREF(chand->user_agent);
 }
 
 const grpc_channel_filter grpc_http_client_filter = {
-    hc_start_transport_stream_op_batch,
+    http_client_start_transport_stream_op_batch,
     grpc_channel_next_op,
     sizeof(call_data),
-    init_call_elem,
+    http_client_init_call_elem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    destroy_call_elem,
+    http_client_destroy_call_elem,
     sizeof(channel_data),
-    init_channel_elem,
-    destroy_channel_elem,
+    http_client_init_channel_elem,
+    http_client_destroy_channel_elem,
     grpc_channel_next_get_info,
     "http-client"};

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -48,7 +48,7 @@ struct channel_data {
   grpc_mdelem default_authority_mdelem;
 };
 
-void authority_start_transport_stream_op_batch(
+void client_authority_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
@@ -72,21 +72,21 @@ void authority_start_transport_stream_op_batch(
 }
 
 /* Constructor for call_data */
-grpc_error* init_call_elem(grpc_call_element* elem,
-                           const grpc_call_element_args* args) {
+grpc_error* client_authority_init_call_elem(
+    grpc_call_element* elem, const grpc_call_element_args* args) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->call_combiner = args->call_combiner;
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for call_data */
-void destroy_call_elem(grpc_call_element* elem,
-                       const grpc_call_final_info* final_info,
-                       grpc_closure* ignored) {}
+void client_authority_destroy_call_elem(grpc_call_element* elem,
+                                        const grpc_call_final_info* final_info,
+                                        grpc_closure* ignored) {}
 
 /* Constructor for channel_data */
-grpc_error* init_channel_elem(grpc_channel_element* elem,
-                              grpc_channel_element_args* args) {
+grpc_error* client_authority_init_channel_elem(
+    grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   const grpc_arg* default_authority_arg =
       grpc_channel_args_find(args->channel_args, GRPC_ARG_DEFAULT_AUTHORITY);
@@ -110,7 +110,7 @@ grpc_error* init_channel_elem(grpc_channel_element* elem,
 }
 
 /* Destructor for channel data */
-void destroy_channel_elem(grpc_channel_element* elem) {
+void client_authority_destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_slice_unref_internal(chand->default_authority);
   GRPC_MDELEM_UNREF(chand->default_authority_mdelem);
@@ -118,15 +118,15 @@ void destroy_channel_elem(grpc_channel_element* elem) {
 }  // namespace
 
 const grpc_channel_filter grpc_client_authority_filter = {
-    authority_start_transport_stream_op_batch,
+    client_authority_start_transport_stream_op_batch,
     grpc_channel_next_op,
     sizeof(call_data),
-    init_call_elem,
+    client_authority_init_call_elem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    destroy_call_elem,
+    client_authority_destroy_call_elem,
     sizeof(channel_data),
-    init_channel_elem,
-    destroy_channel_elem,
+    client_authority_init_channel_elem,
+    client_authority_destroy_channel_elem,
     grpc_channel_next_get_info,
     "authority"};