grpc 1.33.0.pre1 → 1.34.0

data/src/core/ext/upbdefs-generated/validate/validate.upbdefs.h

@@ -0,0 +1,145 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     validate/validate.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#ifndef VALIDATE_VALIDATE_PROTO_UPBDEFS_H_
+#define VALIDATE_VALIDATE_PROTO_UPBDEFS_H_
+
+#include "upb/def.h"
+#include "upb/port_def.inc"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "upb/def.h"
+
+#include "upb/port_def.inc"
+
+extern upb_def_init validate_validate_proto_upbdefinit;
+
+UPB_INLINE const upb_msgdef *validate_FieldRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.FieldRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_FloatRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.FloatRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_DoubleRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.DoubleRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_Int32Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.Int32Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_Int64Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.Int64Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_UInt32Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.UInt32Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_UInt64Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.UInt64Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_SInt32Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.SInt32Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_SInt64Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.SInt64Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_Fixed32Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.Fixed32Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_Fixed64Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.Fixed64Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_SFixed32Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.SFixed32Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_SFixed64Rules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.SFixed64Rules");
+}
+
+UPB_INLINE const upb_msgdef *validate_BoolRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.BoolRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_StringRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.StringRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_BytesRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.BytesRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_EnumRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.EnumRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_MessageRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.MessageRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_RepeatedRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.RepeatedRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_MapRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.MapRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_AnyRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.AnyRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_DurationRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.DurationRules");
+}
+
+UPB_INLINE const upb_msgdef *validate_TimestampRules_getmsgdef(upb_symtab *s) {
+  _upb_symtab_loaddefinit(s, &validate_validate_proto_upbdefinit);
+  return upb_symtab_lookupmsg(s, "validate.TimestampRules");
+}
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif  /* VALIDATE_VALIDATE_PROTO_UPBDEFS_H_ */

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

@@ -23,7 +23,7 @@
 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/security/certificate_provider.h"
+#include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 namespace grpc_core {
 
@@ -32,13 +32,15 @@ namespace grpc_core {
 class CertificateProviderFactory {
  public:
   // Interface for configs for CertificateProviders.
-  class Config {
+  class Config : public RefCounted<Config> {
    public:
-    virtual ~Config() = default;
+    ~Config() override = default;
 
     // Name of the type of the CertificateProvider. Unique to each type of
     // config.
     virtual const char* name() const = 0;
+
+    virtual std::string ToString() const = 0;
   };
 
   virtual ~CertificateProviderFactory() = default;
@@ -46,12 +48,12 @@ class CertificateProviderFactory {
   // Name of the plugin.
   virtual const char* name() const = 0;
 
-  virtual std::unique_ptr<Config> CreateCertificateProviderConfig(
+  virtual RefCountedPtr<Config> CreateCertificateProviderConfig(
       const Json& config_json, grpc_error** error) = 0;
 
   // Create a CertificateProvider instance from config.
   virtual RefCountedPtr<grpc_tls_certificate_provider>
-  CreateCertificateProvider(std::unique_ptr<Config> config) = 0;
+  CreateCertificateProvider(RefCountedPtr<Config> config) = 0;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,84 @@
+//
+//
+// Copyright 2020 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.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/certificate_provider_store.h"
+
+#include "src/core/ext/xds/certificate_provider_registry.h"
+
+namespace grpc_core {
+
+// If a certificate provider is created, the CertificateProviderStore
+// maintains a raw pointer to the created CertificateProviderWrapper so that
+// future calls to `CreateOrGetCertificateProvider()` with the same key result
+// in returning a ref to this created certificate provider. This entry is
+// deleted when the refcount to this provider reaches zero.
+RefCountedPtr<grpc_tls_certificate_provider>
+CertificateProviderStore::CreateOrGetCertificateProvider(
+    absl::string_view key) {
+  RefCountedPtr<CertificateProviderWrapper> result;
+  MutexLock lock(&mu_);
+  auto it = certificate_providers_map_.find(key);
+  if (it == certificate_providers_map_.end()) {
+    it = certificate_providers_map_.insert({key, nullptr}).first;
+  } else {
+    result = it->second->RefIfNonZero();
+  }
+  if (result == nullptr) {
+    result = CreateCertificateProviderLocked(key);
+    it->second = result.get();
+  }
+  return result;
+}
+
+RefCountedPtr<CertificateProviderStore::CertificateProviderWrapper>
+CertificateProviderStore::CreateCertificateProviderLocked(
+    absl::string_view key) {
+  auto plugin_config_it = plugin_config_map_.find(std::string(key));
+  if (plugin_config_it == plugin_config_map_.end()) {
+    return nullptr;
+  }
+  CertificateProviderFactory* factory =
+      CertificateProviderRegistry::LookupCertificateProviderFactory(
+          plugin_config_it->second.plugin_name);
+  if (factory == nullptr) {
+    // This should never happen since an entry is only inserted in the
+    // plugin_config_map_ if the corresponding factory was found when parsing
+    // the xDS bootstrap file.
+    gpr_log(GPR_ERROR, "Certificate provider factory %s not found",
+            plugin_config_it->second.plugin_name.c_str());
+    return nullptr;
+  }
+  return MakeRefCounted<CertificateProviderWrapper>(
+      factory->CreateCertificateProvider(plugin_config_it->second.config), this,
+      plugin_config_it->first);
+}
+
+void CertificateProviderStore::ReleaseCertificateProvider(
+    absl::string_view key, CertificateProviderWrapper* wrapper) {
+  MutexLock lock(&mu_);
+  auto it = certificate_providers_map_.find(key);
+  if (it != certificate_providers_map_.end()) {
+    if (it->second == wrapper) {
+      certificate_providers_map_.erase(it);
+    }
+  }
+}
+
+}  // namespace grpc_core

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

@@ -23,26 +23,83 @@
 
 #include <map>
 
+#include "absl/strings/string_view.h"
+
+#include "src/core/ext/xds/certificate_provider_factory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/security/certificate_provider.h"
+#include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 namespace grpc_core {
 
-// Map for xDS based grpc_tls_certificate_provider instances.
+// Map for xDS based grpc_tls_certificate_provider instances. The store should
+// outlive the refs taken via `CreateOrGetCertificateProvider()`.
 class CertificateProviderStore {
  public:
-  // If a provider corresponding to the config is found, a raw pointer to the
-  // grpc_tls_certificate_provider in the map is returned. If no provider is
-  // found for a key, a new provider is created. The CertificateProviderStore
-  // maintains a ref to the grpc_tls_certificate_provider for its entire
-  // lifetime.
+  struct PluginDefinition {
+    std::string plugin_name;
+    RefCountedPtr<CertificateProviderFactory::Config> config;
+  };
+
+  // Maps plugin instance (opaque) name to plugin defition.
+  typedef std::map<std::string, PluginDefinition> PluginDefinitionMap;
+
+  CertificateProviderStore(PluginDefinitionMap plugin_config_map)
+      : plugin_config_map_(std::move(plugin_config_map)) {}
+
+  // If a certificate provider corresponding to the instance name \a key is
+  // found, a ref to the grpc_tls_certificate_provider is returned. If no
+  // provider is found for the key, a new provider is created from the plugin
+  // definition map.
+  // Returns nullptr on failure to get or create a new certificate provider.
   RefCountedPtr<grpc_tls_certificate_provider> CreateOrGetCertificateProvider(
       absl::string_view key);
 
  private:
+  // A thin wrapper around `grpc_tls_certificate_provider` which allows removing
+  // the entry from the CertificateProviderStore when the refcount reaches zero.
+  class CertificateProviderWrapper : public grpc_tls_certificate_provider {
+   public:
+    CertificateProviderWrapper(
+        RefCountedPtr<grpc_tls_certificate_provider> certificate_provider,
+        CertificateProviderStore* store, absl::string_view key)
+        : certificate_provider_(std::move(certificate_provider)),
+          store_(store),
+          key_(key) {}
+
+    ~CertificateProviderWrapper() override {
+      store_->ReleaseCertificateProvider(key_, this);
+    }
+
+    grpc_core::RefCountedPtr<grpc_tls_certificate_distributor> distributor()
+        const override {
+      return certificate_provider_->distributor();
+    }
+
+    grpc_pollset_set* interested_parties() const override {
+      return certificate_provider_->interested_parties();
+    }
+
+   private:
+    RefCountedPtr<grpc_tls_certificate_provider> certificate_provider_;
+    CertificateProviderStore* store_;
+    absl::string_view key_;
+  };
+
+  RefCountedPtr<CertificateProviderWrapper> CreateCertificateProviderLocked(
+      absl::string_view key);
+
+  // Releases a previously created certificate provider from the certificate
+  // provider map if the value matches \a wrapper.
+  void ReleaseCertificateProvider(absl::string_view key,
+                                  CertificateProviderWrapper* wrapper);
+
+  Mutex mu_;
+  // Map of plugin configurations
+  PluginDefinitionMap plugin_config_map_;
   // Underlying map for the providers.
-  std::map<std::string, RefCountedPtr<grpc_tls_certificate_provider>> map_;
+  std::map<absl::string_view, CertificateProviderWrapper*>
+      certificate_providers_map_;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,119 @@
+//
+//
+// Copyright 2020 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.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/file_watcher_certificate_provider_factory.h"
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
+#include "src/core/lib/json/json_util.h"
+
+namespace grpc_core {
+
+namespace {
+
+const char* kFileWatcherPlugin = "file_watcher";
+
+}  // namespace
+
+//
+// FileWatcherCertificateProviderFactory::Config
+//
+
+const char* FileWatcherCertificateProviderFactory::Config::name() const {
+  return kFileWatcherPlugin;
+}
+
+std::string FileWatcherCertificateProviderFactory::Config::ToString() const {
+  std::vector<std::string> parts;
+  parts.push_back("{");
+  if (!identity_cert_file_.empty()) {
+    parts.push_back(
+        absl::StrFormat("certificate_file=\"%s\", ", identity_cert_file_));
+  }
+  if (!identity_cert_file_.empty()) {
+    parts.push_back(
+        absl::StrFormat("private_key_file=\"%s\", ", private_key_file_));
+  }
+  if (!identity_cert_file_.empty()) {
+    parts.push_back(
+        absl::StrFormat("ca_certificate_file=\"%s\", ", root_cert_file_));
+  }
+  parts.push_back(
+      absl::StrFormat("refresh_interval=%ldms}", refresh_interval_ms_));
+  return absl::StrJoin(parts, "");
+}
+
+RefCountedPtr<FileWatcherCertificateProviderFactory::Config>
+FileWatcherCertificateProviderFactory::Config::Parse(const Json& config_json,
+                                                     grpc_error** error) {
+  auto config = MakeRefCounted<FileWatcherCertificateProviderFactory::Config>();
+  if (config_json.type() != Json::Type::OBJECT) {
+    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "error:config type should be OBJECT.");
+    return nullptr;
+  }
+  std::vector<grpc_error*> error_list;
+  ParseJsonObjectField(config_json.object_value(), "certificate_file",
+                       &config->identity_cert_file_, &error_list, false);
+  ParseJsonObjectField(config_json.object_value(), "private_key_file",
+                       &config->private_key_file_, &error_list, false);
+  if (config->identity_cert_file_.empty() !=
+      config->private_key_file_.empty()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "fields \"certificate_file\" and \"private_key_file\" must be both set "
+        "or both unset."));
+  }
+  ParseJsonObjectField(config_json.object_value(), "ca_certificate_file",
+                       &config->root_cert_file_, &error_list, false);
+  if (config->identity_cert_file_.empty() && config->root_cert_file_.empty()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "At least one of \"certificate_file\" and \"ca_certificate_file\" must "
+        "be specified."));
+  }
+  if (!ParseJsonObjectFieldAsDuration(
+          config_json.object_value(), "refresh_interval",
+          &config->refresh_interval_ms_, &error_list, false)) {
+    config->refresh_interval_ms_ = 10 * 60 * 1000;  // 10 minutes default
+  }
+  if (!error_list.empty()) {
+    *error = GRPC_ERROR_CREATE_FROM_VECTOR(
+        "Error parsing file watcher certificate provider config", &error_list);
+    return nullptr;
+  }
+  return config;
+}
+
+//
+// FileWatcherCertificateProviderFactory
+//
+
+const char* FileWatcherCertificateProviderFactory::name() const {
+  return kFileWatcherPlugin;
+}
+
+RefCountedPtr<CertificateProviderFactory::Config>
+FileWatcherCertificateProviderFactory::CreateCertificateProviderConfig(
+    const Json& config_json, grpc_error** error) {
+  return FileWatcherCertificateProviderFactory::Config::Parse(config_json,
+                                                              error);
+}
+
+}  // namespace grpc_core