grpc 1.46.3-x86_64-linux → 1.47.0-x86_64-linux

data/src/core/ext/upb-generated/xds/service/orca/v3/orca.upb.h

@@ -0,0 +1,109 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     xds/service/orca/v3/orca.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#ifndef XDS_SERVICE_ORCA_V3_ORCA_PROTO_UPB_H_
+#define XDS_SERVICE_ORCA_V3_ORCA_PROTO_UPB_H_
+
+#include "upb/msg_internal.h"
+#include "upb/decode.h"
+#include "upb/decode_fast.h"
+#include "upb/encode.h"
+
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct xds_service_orca_v3_OrcaLoadReportRequest;
+typedef struct xds_service_orca_v3_OrcaLoadReportRequest xds_service_orca_v3_OrcaLoadReportRequest;
+extern const upb_MiniTable xds_service_orca_v3_OrcaLoadReportRequest_msginit;
+struct google_protobuf_Duration;
+extern const upb_MiniTable google_protobuf_Duration_msginit;
+
+
+
+/* xds.service.orca.v3.OrcaLoadReportRequest */
+
+UPB_INLINE xds_service_orca_v3_OrcaLoadReportRequest* xds_service_orca_v3_OrcaLoadReportRequest_new(upb_Arena* arena) {
+  return (xds_service_orca_v3_OrcaLoadReportRequest*)_upb_Message_New(&xds_service_orca_v3_OrcaLoadReportRequest_msginit, arena);
+}
+UPB_INLINE xds_service_orca_v3_OrcaLoadReportRequest* xds_service_orca_v3_OrcaLoadReportRequest_parse(const char* buf, size_t size, upb_Arena* arena) {
+  xds_service_orca_v3_OrcaLoadReportRequest* ret = xds_service_orca_v3_OrcaLoadReportRequest_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, ret, &xds_service_orca_v3_OrcaLoadReportRequest_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE xds_service_orca_v3_OrcaLoadReportRequest* xds_service_orca_v3_OrcaLoadReportRequest_parse_ex(const char* buf, size_t size,
+                           const upb_ExtensionRegistry* extreg,
+                           int options, upb_Arena* arena) {
+  xds_service_orca_v3_OrcaLoadReportRequest* ret = xds_service_orca_v3_OrcaLoadReportRequest_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, ret, &xds_service_orca_v3_OrcaLoadReportRequest_msginit, extreg, options, arena) !=
+      kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* xds_service_orca_v3_OrcaLoadReportRequest_serialize(const xds_service_orca_v3_OrcaLoadReportRequest* msg, upb_Arena* arena, size_t* len) {
+  return upb_Encode(msg, &xds_service_orca_v3_OrcaLoadReportRequest_msginit, 0, arena, len);
+}
+UPB_INLINE char* xds_service_orca_v3_OrcaLoadReportRequest_serialize_ex(const xds_service_orca_v3_OrcaLoadReportRequest* msg, int options,
+                                 upb_Arena* arena, size_t* len) {
+  return upb_Encode(msg, &xds_service_orca_v3_OrcaLoadReportRequest_msginit, options, arena, len);
+}
+UPB_INLINE bool xds_service_orca_v3_OrcaLoadReportRequest_has_report_interval(const xds_service_orca_v3_OrcaLoadReportRequest* msg) {
+  return _upb_hasbit(msg, 1);
+}
+UPB_INLINE void xds_service_orca_v3_OrcaLoadReportRequest_clear_report_interval(const xds_service_orca_v3_OrcaLoadReportRequest* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const upb_Message*) = NULL;
+}
+UPB_INLINE const struct google_protobuf_Duration* xds_service_orca_v3_OrcaLoadReportRequest_report_interval(const xds_service_orca_v3_OrcaLoadReportRequest* msg) {
+  return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const struct google_protobuf_Duration*);
+}
+UPB_INLINE void xds_service_orca_v3_OrcaLoadReportRequest_clear_request_cost_names(const xds_service_orca_v3_OrcaLoadReportRequest* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE upb_StringView const* xds_service_orca_v3_OrcaLoadReportRequest_request_cost_names(const xds_service_orca_v3_OrcaLoadReportRequest* msg, size_t* len) {
+  return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
+
+UPB_INLINE void xds_service_orca_v3_OrcaLoadReportRequest_set_report_interval(xds_service_orca_v3_OrcaLoadReportRequest *msg, struct google_protobuf_Duration* value) {
+  _upb_sethas(msg, 1);
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), struct google_protobuf_Duration*) = value;
+}
+UPB_INLINE struct google_protobuf_Duration* xds_service_orca_v3_OrcaLoadReportRequest_mutable_report_interval(xds_service_orca_v3_OrcaLoadReportRequest* msg, upb_Arena* arena) {
+  struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)xds_service_orca_v3_OrcaLoadReportRequest_report_interval(msg);
+  if (sub == NULL) {
+    sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
+    if (!sub) return NULL;
+    xds_service_orca_v3_OrcaLoadReportRequest_set_report_interval(msg, sub);
+  }
+  return sub;
+}
+UPB_INLINE upb_StringView* xds_service_orca_v3_OrcaLoadReportRequest_mutable_request_cost_names(xds_service_orca_v3_OrcaLoadReportRequest* msg, size_t* len) {
+  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
+}
+UPB_INLINE upb_StringView* xds_service_orca_v3_OrcaLoadReportRequest_resize_request_cost_names(xds_service_orca_v3_OrcaLoadReportRequest* msg, size_t len, upb_Arena* arena) {
+  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, UPB_SIZE(3, 4), arena);
+}
+UPB_INLINE bool xds_service_orca_v3_OrcaLoadReportRequest_add_request_cost_names(xds_service_orca_v3_OrcaLoadReportRequest* msg, upb_StringView val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), UPB_SIZE(3, 4), &val, arena);
+}
+
+extern const upb_MiniTable_File xds_service_orca_v3_orca_proto_upb_file_layout;
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif  /* XDS_SERVICE_ORCA_V3_ORCA_PROTO_UPB_H_ */

data/src/core/ext/xds/certificate_provider_store.cc

@@ -28,8 +28,10 @@ namespace grpc_core {
 // CertificateProviderStore::CertificateProviderWrapper
 //
 
-const char* CertificateProviderStore::CertificateProviderWrapper::type() const {
-  return "Wrapper";
+UniqueTypeName CertificateProviderStore::CertificateProviderWrapper::type()
+    const {
+  static UniqueTypeName::Factory kFactory("Wrapper");
+  return kFactory.Create();
 }
 
 // If a certificate provider is created, the CertificateProviderStore

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

@@ -90,7 +90,7 @@ class CertificateProviderStore
           static_cast<const grpc_tls_certificate_provider*>(this), other);
     }
 
-    const char* type() const override;
+    UniqueTypeName type() const override;
 
     absl::string_view key() const { return key_; }
 

data/src/core/ext/xds/xds_certificate_provider.cc

@@ -263,7 +263,10 @@ XdsCertificateProvider::~XdsCertificateProvider() {
   distributor_->SetWatchStatusCallback(nullptr);
 }
 
-const char* XdsCertificateProvider::type() const { return "Xds"; }
+UniqueTypeName XdsCertificateProvider::type() const {
+  static UniqueTypeName::Factory kFactory("Xds");
+  return kFactory.Create();
+}
 
 bool XdsCertificateProvider::ProvidesRootCerts(const std::string& cert_name) {
   MutexLock lock(&mu_);

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

@@ -39,7 +39,7 @@ class XdsCertificateProvider : public grpc_tls_certificate_provider {
     return distributor_;
   }
 
-  const char* type() const override;
+  UniqueTypeName type() const override;
 
   bool ProvidesRootCerts(const std::string& cert_name);
   void UpdateRootCertNameAndDistributor(

data/src/core/ext/xds/xds_channel_stack_modifier.cc

@@ -53,7 +53,7 @@ bool XdsChannelStackModifier::ModifyChannelStack(ChannelStackBuilder* builder) {
   // Insert the filters after the census filter if present.
   auto it = builder->mutable_stack()->begin();
   while (it != builder->mutable_stack()->end()) {
-    const char* filter_name_at_it = it->filter->name;
+    const char* filter_name_at_it = (*it)->name;
     if (strcmp("census_server", filter_name_at_it) == 0 ||
         strcmp("opencensus_server", filter_name_at_it) == 0) {
       break;
@@ -71,8 +71,7 @@ bool XdsChannelStackModifier::ModifyChannelStack(ChannelStackBuilder* builder) {
     ++it;
   }
   for (const grpc_channel_filter* filter : filters_) {
-    it = builder->mutable_stack()->insert(
-        it, ChannelStackBuilder::StackEntry{filter, nullptr});
+    it = builder->mutable_stack()->insert(it, filter);
     ++it;
   }
   return true;
@@ -96,9 +95,10 @@ XdsChannelStackModifier::GetFromChannelArgs(const grpc_channel_args& args) {
 void RegisterXdsChannelStackModifier(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(
       GRPC_SERVER_CHANNEL, INT_MAX, [](ChannelStackBuilder* builder) {
+        const grpc_channel_args* channel_args = builder->channel_args().ToC();
         RefCountedPtr<XdsChannelStackModifier> channel_stack_modifier =
-            XdsChannelStackModifier::GetFromChannelArgs(
-                *builder->channel_args());
+            XdsChannelStackModifier::GetFromChannelArgs(*channel_args);
+        grpc_channel_args_destroy(channel_args);
         if (channel_stack_modifier != nullptr) {
           return channel_stack_modifier->ModifyChannelStack(builder);
         }

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

@@ -198,9 +198,20 @@ class XdsClient::ChannelState::AdsCallState
       Unref(DEBUG_LOCATION, "Orphan");
     }
 
-    void MaybeStartTimer(RefCountedPtr<AdsCallState> ads_calld) {
-      if (timer_started_) return;
-      timer_started_ = true;
+    void MaybeStartTimer(RefCountedPtr<AdsCallState> ads_calld)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
+      if (!timer_start_needed_) return;
+      timer_start_needed_ = false;
+      // Check if we already have a cached version of this resource
+      // (i.e., if this is the initial request for the resource after an
+      // ADS stream restart).  If so, we don't start the timer, because
+      // (a) we already have the resource and (b) the server may
+      // optimize by not resending the resource that we already have.
+      auto& authority_state =
+          ads_calld->xds_client()->authority_state_map_[name_.authority];
+      ResourceState& state = authority_state.resource_map[type_][name_.key];
+      if (state.resource != nullptr) return;
+      // Start timer.
       ads_calld_ = std::move(ads_calld);
       Ref(DEBUG_LOCATION, "timer").release();
       timer_pending_ = true;
@@ -211,6 +222,18 @@ class XdsClient::ChannelState::AdsCallState
     }
 
     void MaybeCancelTimer() {
+      // If the timer hasn't been started yet, make sure we don't start
+      // it later.  This can happen if the last watch for an LDS or CDS
+      // resource is cancelled and then restarted, both while an ADS
+      // request for a different resource type is being sent (causing
+      // the unsubscription and then resubscription requests to be
+      // queued), and then we get a response for the LDS or CDS resource.
+      // In that case, we would call MaybeCancelTimer() when we receive the
+      // response and then MaybeStartTimer() when we finally send the new
+      // LDS or CDS request, thus causing the timer to fire when it shouldn't.
+      // For details, see https://github.com/grpc/grpc/issues/29583.
+      // TODO(roth): Find a way to write a test for this case.
+      timer_start_needed_ = false;
       if (timer_pending_) {
         grpc_timer_cancel(&timer_);
         timer_pending_ = false;
@@ -233,23 +256,23 @@ class XdsClient::ChannelState::AdsCallState
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
       if (error == GRPC_ERROR_NONE && timer_pending_) {
         timer_pending_ = false;
-        absl::Status watcher_error = absl::UnavailableError(absl::StrFormat(
-            "timeout obtaining resource {type=%s name=%s} from xds server",
-            type_->type_url(),
-            XdsClient::ConstructFullXdsResourceName(
-                name_.authority, type_->type_url(), name_.key)));
         if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-          gpr_log(GPR_INFO, "[xds_client %p] xds server %s: %s",
+          gpr_log(GPR_INFO,
+                  "[xds_client %p] xds server %s: timeout obtaining resource "
+                  "{type=%s name=%s} from xds server",
                   ads_calld_->xds_client(),
                   ads_calld_->chand()->server_.server_uri.c_str(),
-                  watcher_error.ToString().c_str());
+                  std::string(type_->type_url()).c_str(),
+                  XdsClient::ConstructFullXdsResourceName(
+                      name_.authority, type_->type_url(), name_.key)
+                      .c_str());
         }
         auto& authority_state =
             ads_calld_->xds_client()->authority_state_map_[name_.authority];
         ResourceState& state = authority_state.resource_map[type_][name_.key];
         state.meta.client_status = XdsApi::ResourceMetadata::DOES_NOT_EXIST;
-        ads_calld_->xds_client()->NotifyWatchersOnErrorLocked(state.watchers,
-                                                              watcher_error);
+        ads_calld_->xds_client()->NotifyWatchersOnResourceDoesNotExist(
+            state.watchers);
       }
       GRPC_ERROR_UNREF(error);
     }
@@ -258,7 +281,7 @@ class XdsClient::ChannelState::AdsCallState
     const XdsResourceName name_;
 
     RefCountedPtr<AdsCallState> ads_calld_;
-    bool timer_started_ = false;
+    bool timer_start_needed_ = true;
     bool timer_pending_ = false;
     grpc_timer timer_;
     grpc_closure timer_callback_;
@@ -294,7 +317,8 @@ class XdsClient::ChannelState::AdsCallState
 
   // Constructs a list of resource names of a given type for an ADS
   // request.  Also starts the timer for each resource if needed.
-  std::vector<std::string> ResourceNamesForRequest(const XdsResourceType* type);
+  std::vector<std::string> ResourceNamesForRequest(const XdsResourceType* type)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
   // The owning RetryableCall<>.
   RefCountedPtr<RetryableCall<AdsCallState>> parent_;
@@ -555,7 +579,7 @@ namespace {
 bool IsLameChannel(grpc_channel* channel) {
   grpc_channel_element* elem =
       grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
-  return elem->filter == &grpc_lame_filter;
+  return elem->filter == &LameClientFilter::kFilter;
 }
 
 }  // namespace
@@ -566,7 +590,8 @@ void XdsClient::ChannelState::StartConnectivityWatchLocked() {
         absl::UnavailableError("xds client has a lame channel"));
     return;
   }
-  ClientChannel* client_channel = ClientChannel::GetFromChannel(channel_);
+  ClientChannel* client_channel =
+      ClientChannel::GetFromChannel(Channel::FromC(channel_));
   GPR_ASSERT(client_channel != nullptr);
   watcher_ = new StateWatcher(WeakRef(DEBUG_LOCATION, "ChannelState+watch"));
   client_channel->AddConnectivityWatcher(
@@ -578,7 +603,8 @@ void XdsClient::ChannelState::CancelConnectivityWatchLocked() {
   if (IsLameChannel(channel_)) {
     return;
   }
-  ClientChannel* client_channel = ClientChannel::GetFromChannel(channel_);
+  ClientChannel* client_channel =
+      ClientChannel::GetFromChannel(Channel::FromC(channel_));
   GPR_ASSERT(client_channel != nullptr);
   client_channel->RemoveConnectivityWatcher(watcher_);
 }
@@ -1925,11 +1951,9 @@ void XdsClient::CancelResourceWatch(const XdsResourceType* type,
                                     bool delay_unsubscription) {
   auto resource_name = ParseXdsResourceName(name, type);
   MutexLock lock(&mu_);
-  if (!resource_name.ok()) {
-    invalid_watchers_.erase(watcher);
-    return;
-  }
-  if (shutting_down_) return;
+  // We cannot be sure whether the watcher is in invalid_watchers_ or in
+  // authority_state_map_, so we check both, just to be safe.
+  invalid_watchers_.erase(watcher);
   // Find authority.
   if (!resource_name.ok()) return;
   auto authority_it = authority_state_map_.find(resource_name->authority);

data/src/core/ext/xds/xds_cluster.cc

@@ -25,6 +25,7 @@
 #include "envoy/config/cluster/v3/circuit_breaker.upb.h"
 #include "envoy/config/cluster/v3/cluster.upb.h"
 #include "envoy/config/cluster/v3/cluster.upbdefs.h"
+#include "envoy/config/cluster/v3/outlier_detection.upb.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/config_source.upb.h"
@@ -36,6 +37,8 @@
 
 #include <grpc/support/alloc.h>
 
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_route_config.h"
 #include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
@@ -203,19 +206,6 @@ grpc_error_handle CdsLogicalDnsParse(
   return GRPC_ERROR_NONE;
 }
 
-// TODO(donnadionne): Check to see if cluster types aggregate_cluster and
-// logical_dns are enabled, this will be
-// removed once the cluster types are fully integration-tested and enabled by
-// default.
-bool XdsAggregateAndLogicalDnsClusterEnabled() {
-  char* value = gpr_getenv(
-      "GRPC_XDS_EXPERIMENTAL_ENABLE_AGGREGATE_AND_LOGICAL_DNS_CLUSTER");
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value, &parsed_value);
-  gpr_free(value);
-  return parse_succeeded && parsed_value;
-}
-
 grpc_error_handle CdsResourceParse(
     const XdsEncodingContext& context,
     const envoy_config_cluster_v3_Cluster* cluster, bool /*is_v2*/,
@@ -247,9 +237,6 @@ grpc_error_handle CdsResourceParse(
     if (service_name.size != 0) {
       cds_update->eds_service_name = UpbStringToStdString(service_name);
     }
-  } else if (!XdsAggregateAndLogicalDnsClusterEnabled()) {
-    errors.push_back(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("DiscoveryType is not valid."));
   } else if (envoy_config_cluster_v3_Cluster_type(cluster) ==
              envoy_config_cluster_v3_Cluster_LOGICAL_DNS) {
     cds_update->cluster_type = XdsClusterResource::ClusterType::LOGICAL_DNS;
@@ -398,6 +385,109 @@ grpc_error_handle CdsResourceParse(
       }
     }
   }
+  // As long as outlier detection field is present in the cluster update,
+  // we will end up with a outlier detection in the cluster resource which will
+  // lead to the creation of outlier detection in discovery mechanism.  Values
+  // for outlier detection will be based on fields received and
+  // default values.
+  if (XdsOutlierDetectionEnabled() &&
+      envoy_config_cluster_v3_Cluster_has_outlier_detection(cluster)) {
+    OutlierDetectionConfig outlier_detection_update;
+    const envoy_config_cluster_v3_OutlierDetection* outlier_detection =
+        envoy_config_cluster_v3_Cluster_outlier_detection(cluster);
+    const google_protobuf_Duration* duration =
+        envoy_config_cluster_v3_OutlierDetection_interval(outlier_detection);
+    if (duration != nullptr) {
+      outlier_detection_update.interval = ParseDuration(duration);
+    }
+    duration = envoy_config_cluster_v3_OutlierDetection_base_ejection_time(
+        outlier_detection);
+    if (duration != nullptr) {
+      outlier_detection_update.base_ejection_time = ParseDuration(duration);
+    }
+    duration = envoy_config_cluster_v3_OutlierDetection_max_ejection_time(
+        outlier_detection);
+    if (duration != nullptr) {
+      outlier_detection_update.max_ejection_time = ParseDuration(duration);
+    }
+    const google_protobuf_UInt32Value* max_ejection_percent =
+        envoy_config_cluster_v3_OutlierDetection_max_ejection_percent(
+            outlier_detection);
+    if (max_ejection_percent != nullptr) {
+      outlier_detection_update.max_ejection_percent =
+          google_protobuf_UInt32Value_value(max_ejection_percent);
+    }
+    const google_protobuf_UInt32Value* enforcing_success_rate =
+        envoy_config_cluster_v3_OutlierDetection_enforcing_success_rate(
+            outlier_detection);
+    if (enforcing_success_rate != nullptr) {
+      uint32_t enforcement_percentage =
+          google_protobuf_UInt32Value_value(enforcing_success_rate);
+      if (enforcement_percentage != 0) {
+        OutlierDetectionConfig::SuccessRateEjection success_rate_ejection;
+        success_rate_ejection.enforcement_percentage = enforcement_percentage;
+        const google_protobuf_UInt32Value* minimum_hosts =
+            envoy_config_cluster_v3_OutlierDetection_success_rate_minimum_hosts(
+                outlier_detection);
+        if (minimum_hosts != nullptr) {
+          success_rate_ejection.minimum_hosts =
+              google_protobuf_UInt32Value_value(minimum_hosts);
+        }
+        const google_protobuf_UInt32Value* request_volume =
+            envoy_config_cluster_v3_OutlierDetection_success_rate_request_volume(
+                outlier_detection);
+        if (request_volume != nullptr) {
+          success_rate_ejection.request_volume =
+              google_protobuf_UInt32Value_value(request_volume);
+        }
+        const google_protobuf_UInt32Value* stdev_factor =
+            envoy_config_cluster_v3_OutlierDetection_success_rate_stdev_factor(
+                outlier_detection);
+        if (stdev_factor != nullptr) {
+          success_rate_ejection.stdev_factor =
+              google_protobuf_UInt32Value_value(stdev_factor);
+        }
+        outlier_detection_update.success_rate_ejection = success_rate_ejection;
+      }
+    }
+    const google_protobuf_UInt32Value* enforcing_failure_percentage =
+        envoy_config_cluster_v3_OutlierDetection_enforcing_failure_percentage(
+            outlier_detection);
+    if (enforcing_failure_percentage != nullptr) {
+      uint32_t enforcement_percentage =
+          google_protobuf_UInt32Value_value(enforcing_failure_percentage);
+      if (enforcement_percentage != 0) {
+        OutlierDetectionConfig::FailurePercentageEjection
+            failure_percentage_ejection;
+        failure_percentage_ejection.enforcement_percentage =
+            enforcement_percentage;
+        const google_protobuf_UInt32Value* minimum_hosts =
+            envoy_config_cluster_v3_OutlierDetection_failure_percentage_minimum_hosts(
+                outlier_detection);
+        if (minimum_hosts != nullptr) {
+          failure_percentage_ejection.minimum_hosts =
+              google_protobuf_UInt32Value_value(minimum_hosts);
+        }
+        const google_protobuf_UInt32Value* request_volume =
+            envoy_config_cluster_v3_OutlierDetection_failure_percentage_request_volume(
+                outlier_detection);
+        if (request_volume != nullptr) {
+          failure_percentage_ejection.request_volume =
+              google_protobuf_UInt32Value_value(request_volume);
+        }
+        const google_protobuf_UInt32Value* threshold =
+            envoy_config_cluster_v3_OutlierDetection_failure_percentage_threshold(
+                outlier_detection);
+        if (threshold != nullptr) {
+          failure_percentage_ejection.threshold =
+              google_protobuf_UInt32Value_value(threshold);
+        }
+        outlier_detection_update.failure_percentage_ejection =
+            failure_percentage_ejection;
+      }
+    }
+    cds_update->outlier_detection = outlier_detection_update;
+  }
   return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing CDS resource", &errors);
 }
 

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

@@ -27,6 +27,7 @@
 #include "envoy/extensions/clusters/aggregate/v3/cluster.upbdefs.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upbdefs.h"
 
+#include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
@@ -63,6 +64,8 @@ struct XdsClusterResource {
   // cluster.
   uint32_t max_concurrent_requests = 1024;
 
+  absl::optional<OutlierDetectionConfig> outlier_detection;
+
   bool operator==(const XdsClusterResource& other) const {
     return cluster_type == other.cluster_type &&
            eds_service_name == other.eds_service_name &&

data/src/core/ext/xds/xds_http_fault_filter.cc

@@ -36,6 +36,7 @@
 #include <grpc/grpc.h>
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
+#include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -140,9 +141,8 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
         envoy_extensions_filters_common_fault_v3_FaultDelay_fixed_delay(
             fault_delay);
     if (delay_duration != nullptr) {
-      fault_injection_policy_json["delay"] = absl::StrFormat(
-          "%d.%09ds", google_protobuf_Duration_seconds(delay_duration),
-          google_protobuf_Duration_nanos(delay_duration));
+      fault_injection_policy_json["delay"] =
+          ParseDuration(delay_duration).ToJsonString();
     }
     // Set the headers if we enabled header delay injection control
     if (envoy_extensions_filters_common_fault_v3_FaultDelay_has_header_delay(

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

@@ -109,8 +109,10 @@ std::string XdsListenerResource::FilterChainData::ToString() const {
 //
 
 std::string XdsListenerResource::FilterChainMap::CidrRange::ToString() const {
+  auto addr_str = grpc_sockaddr_to_string(&address, false);
   return absl::StrCat(
-      "{address_prefix=", grpc_sockaddr_to_string(&address, false),
+      "{address_prefix=",
+      addr_str.ok() ? addr_str.value() : addr_str.status().ToString(),
       ", prefix_len=", prefix_len, "}");
 }
 
@@ -776,9 +778,12 @@ grpc_error_handle AddFilterChainDataForSourceIpRange(
   } else {
     for (const auto& prefix_range :
          filter_chain.filter_chain_match.source_prefix_ranges) {
+      auto addr_str = grpc_sockaddr_to_string(&prefix_range.address, false);
+      if (!addr_str.ok()) {
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+      }
       auto insert_result = source_ip_map->emplace(
-          absl::StrCat(grpc_sockaddr_to_string(&prefix_range.address, false),
-                       "/", prefix_range.prefix_len),
+          absl::StrCat(*addr_str, "/", prefix_range.prefix_len),
           XdsListenerResource::FilterChainMap::SourceIp());
       if (insert_result.second) {
         insert_result.first->second.prefix_range.emplace(prefix_range);
@@ -860,9 +865,12 @@ grpc_error_handle AddFilterChainDataForDestinationIpRange(
   } else {
     for (const auto& prefix_range :
          filter_chain.filter_chain_match.prefix_ranges) {
+      auto addr_str = grpc_sockaddr_to_string(&prefix_range.address, false);
+      if (!addr_str.ok()) {
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+      }
       auto insert_result = destination_ip_map->emplace(
-          absl::StrCat(grpc_sockaddr_to_string(&prefix_range.address, false),
-                       "/", prefix_range.prefix_len),
+          absl::StrCat(*addr_str, "/", prefix_range.prefix_len),
           InternalFilterChainMap::DestinationIp());
       if (insert_result.second) {
         insert_result.first->second.prefix_range.emplace(prefix_range);
@@ -968,10 +976,12 @@ grpc_error_handle LdsResourceParse(
       envoy_config_listener_v3_Listener_api_listener(listener);
   const envoy_config_core_v3_Address* address =
       envoy_config_listener_v3_Listener_address(listener);
-  if (api_listener != nullptr && address != nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Listener has both address and ApiListener");
-  }
+  // TODO(roth): Re-enable the following check once
+  // github.com/istio/istio/issues/38914 is resolved.
+  // if (api_listener != nullptr && address != nullptr) {
+  //   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+  //       "Listener has both address and ApiListener");
+  // }
   if (api_listener == nullptr && address == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Listener has neither address nor ApiListener");

data/src/core/ext/xds/xds_server_config_fetcher.cc

@@ -1287,7 +1287,8 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
   grpc_core::ExecCtx exec_ctx;
   args = grpc_core::CoreConfiguration::Get()
              .channel_args_preconditioning()
-             .PreconditionChannelArgs(args);
+             .PreconditionChannelArgs(args)
+             .ToC();
   GRPC_API_TRACE(
       "grpc_server_config_fetcher_xds_create(notifier={on_serving_status_"
       "update=%p, user_data=%p}, args=%p)",