grpc 1.83.1 → 1.84.0

data/src/core/util/status_helper.cc

@@ -54,14 +54,8 @@ const char* GetStatusIntPropertyUrl(StatusIntProperty key) {
   switch (key) {
     case StatusIntProperty::kStreamId:
       return TYPE_URL(TYPE_INT_TAG "stream_id");
-    case StatusIntProperty::kRpcStatus:
-      return TYPE_URL(TYPE_INT_TAG "grpc_status");
     case StatusIntProperty::kHttp2Error:
       return TYPE_URL(TYPE_INT_TAG "http2_error");
-    case StatusIntProperty::ChannelConnectivityState:
-      return TYPE_URL(TYPE_INT_TAG "channel_connectivity_state");
-    case StatusIntProperty::kLbPolicyDrop:
-      return TYPE_URL(TYPE_INT_TAG "lb_policy_drop");
   }
   GPR_UNREACHABLE_CODE(return "unknown");
 }
@@ -80,8 +74,6 @@ absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
   return s;
 }
 
-namespace {
-
 absl::Status ReplaceStatusCode(const absl::Status& status,
                                absl::StatusCode code) {
   absl::Status new_status(code, status.message());
@@ -92,23 +84,13 @@ absl::Status ReplaceStatusCode(const absl::Status& status,
   return new_status;
 }
 
-}  // namespace
-
 void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value) {
-  if (key == StatusIntProperty::kRpcStatus) {
-    // When setting the RPC status, just replace the top-level status code.
-    *status = ReplaceStatusCode(*status, static_cast<absl::StatusCode>(value));
-    return;
-  }
   status->SetPayload(GetStatusIntPropertyUrl(key),
                      absl::Cord(std::to_string(value)));
 }
 
 std::optional<intptr_t> StatusGetInt(const absl::Status& status,
                                      StatusIntProperty key) {
-  if (key == StatusIntProperty::kRpcStatus) {
-    return static_cast<intptr_t>(status.code());
-  }
   auto p = status.GetPayload(GetStatusIntPropertyUrl(key));
   if (p.has_value()) {
     auto sv = p->TryFlat();
@@ -156,8 +138,6 @@ void StatusAddChild(absl::Status* status, absl::Status child) {
   *status = std::move(new_status);
 }
 
-std::vector<absl::Status> StatusGetChildren(absl::Status status) { return {}; }
-
 std::string StatusToString(const absl::Status& status) {
   if (status.ok()) {
     return "OK";

data/src/core/util/status_helper.h

@@ -64,19 +64,9 @@ enum class StatusIntProperty {
   /// wire stream
   // TODO(tjagtap): Remove this when the PH2 migration is done.
   kStreamId,
-  /// grpc status code representing this error
-  // TODO(roth): Remove this after error_flatten experiment is removed.
-  kRpcStatus,
   /// http2 error code associated with the error (see the HTTP2 RFC)
   // TODO(tjagtap): Remove this as part of creating a new HTTP/2 error type.
   kHttp2Error,
-  /// channel connectivity state associated with the error
-  // TODO(roth): Remove this when the promise migration is done.
-  ChannelConnectivityState,
-  /// LB policy drop
-  // TODO(roth): Replace this with something else, possibly a call
-  // context element.
-  kLbPolicyDrop,
 };
 
 /// Creates a status with given additional information
@@ -92,13 +82,12 @@ GRPC_MUST_USE_RESULT
 std::optional<intptr_t> StatusGetInt(const absl::Status& status,
                                      StatusIntProperty key);
 
+absl::Status ReplaceStatusCode(const absl::Status& status,
+                               absl::StatusCode code);
+
 /// Adds a child status to status
 void StatusAddChild(absl::Status* status, absl::Status child);
 
-/// Returns all children status from a status
-GRPC_MUST_USE_RESULT std::vector<absl::Status> StatusGetChildren(
-    absl::Status status);
-
 /// Returns a string representation from status
 /// Error status will be like
 ///   STATUS[:MESSAGE] [{PAYLOADS[, children:[CHILDREN-STATUS-LISTS]]}]

data/src/core/xds/grpc/xds_audit_logger_registry.cc

@@ -16,9 +16,6 @@
 
 #include "src/core/xds/grpc/xds_audit_logger_registry.h"
 
-#include <grpc/support/port_platform.h>
-
-#include <optional>
 #include <string>
 #include <utility>
 
@@ -29,42 +26,64 @@
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
-namespace {
-
 using experimental::AuditLoggerRegistry;
 
-class StdoutLoggerConfigFactory final
-    : public XdsAuditLoggerRegistry::ConfigFactory {
- public:
-  Json::Object ConvertXdsAuditLoggerConfig(
-      const XdsResourceType::DecodeContext& /*context*/,
-      absl::string_view /*configuration*/,
-      ValidationErrors* /*errors*/) override {
-    // Stdout logger has no configuration right now. So we don't process the
-    // config protobuf.
-    return {};
+std::shared_ptr<const experimental::AuditLoggerFactory::Config>
+XdsAuditLoggerRegistry::ParseXdsAuditLoggerConfig(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig*
+        logger_config,
+    ValidationErrors* errors) const {
+  const auto* typed_extension_config =
+      envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig_audit_logger(
+          logger_config);
+  ValidationErrors::ScopedField field(errors, ".audit_logger");
+  if (typed_extension_config == nullptr) {
+    errors->AddError("field not present");
+    return nullptr;
   }
-
-  absl::string_view type() override { return Type(); }
-  absl::string_view name() override { return "stdout_logger"; }
-
-  static absl::string_view Type() {
-    return "envoy.extensions.rbac.audit_loggers.stream.v3.StdoutAuditLog";
+  ValidationErrors::ScopedField field2(errors, ".typed_config");
+  const auto* typed_config =
+      envoy_config_core_v3_TypedExtensionConfig_typed_config(
+          typed_extension_config);
+  auto extension = ExtractXdsExtension(context, typed_config, errors);
+  if (!extension.has_value()) return nullptr;
+  absl::string_view name;
+  Json config;
+  Match(
+      extension->value,
+      // Built-in logger types.
+      [&](absl::string_view serialized_value) {
+        auto it = audit_logger_config_factories_.find(extension->type);
+        if (it == audit_logger_config_factories_.end()) return;
+        name = it->second->name();
+        config = Json::FromObject(it->second->ConvertXdsAuditLoggerConfig(
+            context, serialized_value, errors));
+      },
+      // Custom logger types.
+      [&](Json json) {
+        if (!AuditLoggerRegistry::FactoryExists(extension->type)) return;
+        name = extension->type;
+        config = json;
+      });
+  if (name.empty()) {
+    if (!envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig_is_optional(
+            logger_config)) {
+      errors->AddError("unsupported audit logger type");
+    }
+    return nullptr;
   }
-};
-
-}  // namespace
-
-XdsAuditLoggerRegistry::XdsAuditLoggerRegistry() {
-  audit_logger_config_factories_.emplace(
-      StdoutLoggerConfigFactory::Type(),
-      std::make_unique<StdoutLoggerConfigFactory>());
+  // Validate the converted config.
+  auto parsed_config = AuditLoggerRegistry::ParseConfig(name, config);
+  if (!parsed_config.ok()) {
+    errors->AddError(parsed_config.status().message());
+    return nullptr;
+  }
+  return std::move(*parsed_config);
 }
 
 Json XdsAuditLoggerRegistry::ConvertXdsAuditLoggerConfig(
@@ -120,4 +139,5 @@ Json XdsAuditLoggerRegistry::ConvertXdsAuditLoggerConfig(
   }
   return Json::FromObject({{std::string(name), std::move(config)}});
 }
+
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_audit_logger_registry.h

@@ -17,12 +17,12 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_AUDIT_LOGGER_REGISTRY_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_AUDIT_LOGGER_REGISTRY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <memory>
+#include <utility>
 
 #include "envoy/config/rbac/v3/rbac.upb.h"
+#include "src/core/lib/security/authorization/audit_logging.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
@@ -46,8 +46,22 @@ class XdsAuditLoggerRegistry final {
     virtual absl::string_view name() = 0;
   };
 
-  XdsAuditLoggerRegistry();
+  XdsAuditLoggerRegistry() = default;
+
+  template <typename T>
+  void RegisterFactory(std::unique_ptr<T> factory) {
+    audit_logger_config_factories_.emplace(T::Type(), std::move(factory));
+  }
+
+  std::shared_ptr<const experimental::AuditLoggerFactory::Config>
+  ParseXdsAuditLoggerConfig(
+      const XdsResourceType::DecodeContext& context,
+      const envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig*
+          logger_config,
+      ValidationErrors* errors) const;
 
+  // TODO(roth): Remove this method when removing the
+  // xds_server_filter_chain_per_route experiment.
   Json ConvertXdsAuditLoggerConfig(
       const XdsResourceType::DecodeContext& context,
       const envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig*

data/src/core/xds/grpc/xds_bootstrap_grpc.cc

@@ -16,16 +16,10 @@
 
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 
-#include <grpc/support/json.h>
-#include <stdlib.h>
-
-#include <optional>
+#include <memory>
 #include <string>
-#include <utility>
-#include <vector>
 
 #include "src/core/config/experiment_env_var.h"
-#include "src/core/util/down_cast.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/json/json_reader.h"
@@ -227,9 +221,7 @@ absl::StatusOr<std::unique_ptr<GrpcXdsBootstrap>> GrpcXdsBootstrap::Create(
       return true;
     }
   };
-  auto bootstrap = LoadFromJson<GrpcXdsBootstrap>(*json, XdsJsonArgs());
-  if (!bootstrap.ok()) return bootstrap.status();
-  return std::make_unique<GrpcXdsBootstrap>(std::move(*bootstrap));
+  return LoadFromJson<std::unique_ptr<GrpcXdsBootstrap>>(*json, XdsJsonArgs());
 }
 
 const JsonLoaderInterface* GrpcXdsBootstrap::JsonLoader(const JsonArgs&) {

data/src/core/xds/grpc/xds_bootstrap_grpc.h

@@ -17,8 +17,6 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_BOOTSTRAP_GRPC_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_BOOTSTRAP_GRPC_H
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <memory>
 #include <optional>
@@ -44,6 +42,8 @@ namespace grpc_core {
 
 bool XdsExtProcOnClientEnabled();
 
+class GrpcXdsBootstrapBuilder;
+
 class GrpcXdsBootstrap final : public XdsBootstrap {
  public:
   class GrpcNode final : public Node {
@@ -124,10 +124,6 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
                       ValidationErrors* errors);
   };
 
-  // Creates bootstrap object from json_string.
-  static absl::StatusOr<std::unique_ptr<GrpcXdsBootstrap>> Create(
-      absl::string_view json_string);
-
   static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
   void JsonPostLoad(const Json& json, const JsonArgs& args,
                     ValidationErrors* errors);
@@ -187,6 +183,12 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
   }
 
  private:
+  friend class GrpcXdsBootstrapBuilder;
+
+  // External callers should use GrpcXdsBootstrapBuilder::Build() instead.
+  static absl::StatusOr<std::unique_ptr<GrpcXdsBootstrap>> Create(
+      absl::string_view json_string);
+
   std::vector<GrpcXdsServer> servers_;
   std::optional<GrpcNode> node_;
   std::string client_default_listener_resource_name_template_;