grpc 1.78.0 → 1.80.0.pre1

data/src/core/credentials/call/external/file_external_account_credentials.cc

@@ -55,14 +55,14 @@ void FileExternalAccountCredentials::FileFetchBody::ReadFile() {
   // request because it may have changed since the last request.
   auto content_slice = LoadFile(creds_->file_, /*add_null_terminator=*/false);
   if (!content_slice.ok()) {
-    Finish(content_slice.status());
+    Finish(absl::UnavailableError(content_slice.status().message()));
     return;
   }
   absl::string_view content = content_slice->as_string_view();
   if (creds_->format_type_ == "json") {
     auto content_json = JsonParse(content);
     if (!content_json.ok() || content_json->type() != Json::Type::kObject) {
-      Finish(GRPC_ERROR_CREATE(
+      Finish(absl::UnauthenticatedError(
           "The content of the file is not a valid json object."));
       return;
     }

data/src/core/credentials/transport/channel_creds_registry.h

@@ -29,6 +29,7 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/validation_errors.h"
+#include "src/core/xds/grpc/certificate_provider_store_interface.h"
 #include "absl/strings/string_view.h"
 
 struct grpc_channel_credentials;
@@ -39,6 +40,13 @@ class ChannelCredsConfig : public RefCounted<ChannelCredsConfig> {
  public:
   virtual absl::string_view type() const = 0;
 
+  virtual absl::string_view proto_type() const = 0;
+
+  bool operator==(const ChannelCredsConfig& other) const {
+    if (type() != other.type()) return false;
+    return Equals(other);
+  }
+
   virtual bool Equals(const ChannelCredsConfig& other) const = 0;
 
   virtual std::string ToString() const = 0;
@@ -49,11 +57,19 @@ class ChannelCredsFactory final {
  public:
   virtual ~ChannelCredsFactory() {}
   virtual absl::string_view type() const = delete;
-  virtual RefCountedPtr<ChannelCredsConfig> ParseConfig(
+  virtual RefCountedPtr<const ChannelCredsConfig> ParseConfig(
       const Json& config, const JsonArgs& args,
       ValidationErrors* errors) const = delete;
+  virtual absl::string_view proto_type() const = delete;
+  virtual RefCountedPtr<const ChannelCredsConfig> ParseProto(
+      absl::string_view serialized_proto,
+      const CertificateProviderStoreInterface::PluginDefinitionMap&
+          certificate_provider_definitions,
+      ValidationErrors* errors) const = delete;
   virtual RefCountedPtr<T> CreateChannelCreds(
-      RefCountedPtr<ChannelCredsConfig> config) const = delete;
+      RefCountedPtr<const ChannelCredsConfig> config,
+      CertificateProviderStoreInterface& certificate_provider_store) const =
+      delete;
 };
 
 template <>
@@ -61,18 +77,25 @@ class ChannelCredsFactory<grpc_channel_credentials> {
  public:
   virtual ~ChannelCredsFactory() {}
   virtual absl::string_view type() const = 0;
-  virtual RefCountedPtr<ChannelCredsConfig> ParseConfig(
+  virtual RefCountedPtr<const ChannelCredsConfig> ParseConfig(
       const Json& config, const JsonArgs& args,
       ValidationErrors* errors) const = 0;
+  virtual absl::string_view proto_type() const = 0;
+  virtual RefCountedPtr<const ChannelCredsConfig> ParseProto(
+      absl::string_view serialized_proto,
+      const CertificateProviderStoreInterface::PluginDefinitionMap&
+          certificate_provider_definitions,
+      ValidationErrors* errors) const = 0;
   virtual RefCountedPtr<grpc_channel_credentials> CreateChannelCreds(
-      RefCountedPtr<ChannelCredsConfig> config) const = 0;
+      RefCountedPtr<const ChannelCredsConfig> config,
+      CertificateProviderStoreInterface& certificate_provider_store) const = 0;
 };
 
 template <typename T = grpc_channel_credentials>
 class ChannelCredsRegistry {
  private:
   using FactoryMap =
-      std::map<absl::string_view, std::unique_ptr<ChannelCredsFactory<T>>>;
+      std::map<absl::string_view, std::shared_ptr<ChannelCredsFactory<T>>>;
 
  public:
   static_assert(std::is_base_of<grpc_channel_credentials, T>::value,
@@ -83,42 +106,70 @@ class ChannelCredsRegistry {
    public:
     void RegisterChannelCredsFactory(
         std::unique_ptr<ChannelCredsFactory<T>> factory) {
-      absl::string_view type = factory->type();
-      factories_[type] = std::move(factory);
+      std::shared_ptr<ChannelCredsFactory<T>> shared_factory(
+          std::move(factory));
+      absl::string_view type = shared_factory->type();
+      if (!type.empty()) name_map_[type] = shared_factory;
+      absl::string_view proto_type = shared_factory->proto_type();
+      if (!proto_type.empty()) proto_map_[proto_type] = shared_factory;
     }
+
     ChannelCredsRegistry Build() {
-      return ChannelCredsRegistry<T>(std::move(factories_));
+      return ChannelCredsRegistry<T>(std::move(name_map_),
+                                     std::move(proto_map_));
     }
 
    private:
-    FactoryMap factories_;
+    FactoryMap name_map_;
+    FactoryMap proto_map_;
   };
 
   bool IsSupported(absl::string_view type) const {
-    return factories_.find(type) != factories_.end();
+    return name_map_.find(type) != name_map_.end();
   }
 
-  RefCountedPtr<ChannelCredsConfig> ParseConfig(
+  RefCountedPtr<const ChannelCredsConfig> ParseConfig(
       absl::string_view type, const Json& config, const JsonArgs& args,
       ValidationErrors* errors) const {
-    const auto it = factories_.find(type);
-    if (it == factories_.cend()) return nullptr;
+    const auto it = name_map_.find(type);
+    if (it == name_map_.cend()) return nullptr;
     return it->second->ParseConfig(config, args, errors);
   }
 
+  bool IsProtoSupported(absl::string_view type) const {
+    return proto_map_.find(type) != proto_map_.end();
+  }
+
+  RefCountedPtr<const ChannelCredsConfig> ParseProto(
+      absl::string_view proto_type, absl::string_view serialized_proto,
+      const CertificateProviderStoreInterface::PluginDefinitionMap&
+          certificate_provider_definitions,
+      ValidationErrors* errors) const {
+    const auto it = proto_map_.find(proto_type);
+    if (it == proto_map_.cend()) return nullptr;
+    return it->second->ParseProto(serialized_proto,
+                                  certificate_provider_definitions, errors);
+  }
+
   RefCountedPtr<T> CreateChannelCreds(
-      RefCountedPtr<ChannelCredsConfig> config) const {
+      RefCountedPtr<const ChannelCredsConfig> config,
+      CertificateProviderStoreInterface& certificate_provider_store) const {
     if (config == nullptr) return nullptr;
-    const auto it = factories_.find(config->type());
-    if (it == factories_.cend()) return nullptr;
-    return it->second->CreateChannelCreds(std::move(config));
+    auto it = name_map_.find(config->type());
+    if (it == name_map_.cend()) {
+      it = proto_map_.find(config->proto_type());
+      if (it == proto_map_.cend()) return nullptr;
+    }
+    return it->second->CreateChannelCreds(std::move(config),
+                                          certificate_provider_store);
   }
 
  private:
-  explicit ChannelCredsRegistry(FactoryMap factories)
-      : factories_(std::move(factories)) {}
+  ChannelCredsRegistry(FactoryMap name_map, FactoryMap proto_map)
+      : name_map_(std::move(name_map)), proto_map_(std::move(proto_map)) {}
 
-  FactoryMap factories_;
+  FactoryMap name_map_;
+  FactoryMap proto_map_;
 };
 
 }  // namespace grpc_core