grpc 1.44.0.pre2 → 1.45.0

data/src/core/lib/resolver/resolver_factory.h

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+// Copyright 2015 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_LIB_RESOLVER_RESOLVER_FACTORY_H
 #define GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
@@ -41,8 +39,6 @@ class WorkSerializer;
 struct ResolverArgs {
   /// The parsed URI to resolve.
   URI uri;
-  /// The URI string.
-  std::string uri_string;
   /// Channel args to be included in resolver results.
   const grpc_channel_args* args = nullptr;
   /// Used to drive I/O in the name resolution process.
@@ -55,6 +51,12 @@ struct ResolverArgs {
 
 class ResolverFactory {
  public:
+  virtual ~ResolverFactory() {}
+
+  /// Returns the URI scheme that this factory implements.
+  /// Caller does NOT take ownership of result.
+  virtual absl::string_view scheme() const = 0;
+
   /// Returns a bool indicating whether the input uri is valid to create a
   /// resolver.
   virtual bool IsValidUri(const URI& uri) const = 0;
@@ -67,14 +69,8 @@ class ResolverFactory {
   virtual std::string GetDefaultAuthority(const URI& uri) const {
     return std::string(absl::StripPrefix(uri.path(), "/"));
   }
-
-  /// Returns the URI scheme that this factory implements.
-  /// Caller does NOT take ownership of result.
-  virtual const char* scheme() const = 0;
-
-  virtual ~ResolverFactory() {}
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H */
+#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H

data/src/core/lib/resolver/resolver_registry.cc

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+// Copyright 2015 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>
 
@@ -24,6 +22,7 @@
 
 #include <vector>
 
+#include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
@@ -31,139 +30,63 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-namespace grpc_core {
-
-namespace {
-
-class RegistryState {
- public:
-  RegistryState() : default_prefix_(gpr_strdup("dns:///")) {}
-
-  void SetDefaultPrefix(const char* default_resolver_prefix) {
-    GPR_ASSERT(default_resolver_prefix != nullptr);
-    GPR_ASSERT(*default_resolver_prefix != '\0');
-    default_prefix_.reset(gpr_strdup(default_resolver_prefix));
-  }
-
-  void RegisterResolverFactory(std::unique_ptr<ResolverFactory> factory) {
-    for (size_t i = 0; i < factories_.size(); ++i) {
-      GPR_ASSERT(strcmp(factories_[i]->scheme(), factory->scheme()) != 0);
-    }
-    factories_.push_back(std::move(factory));
-  }
-
-  ResolverFactory* LookupResolverFactory(absl::string_view scheme) const {
-    for (size_t i = 0; i < factories_.size(); ++i) {
-      if (scheme == factories_[i]->scheme()) {
-        return factories_[i].get();
-      }
-    }
-    return nullptr;
-  }
-
-  // Returns the factory for the scheme of \a target.  If \a target does
-  // not parse as a URI, prepends \a default_prefix_ and tries again.
-  // If URI parsing is successful (in either attempt), sets \a uri to
-  // point to the parsed URI.
-  // If \a default_prefix_ needs to be prepended, sets \a canonical_target
-  // to the canonical target string.
-  ResolverFactory* FindResolverFactory(absl::string_view target, URI* uri,
-                                       std::string* canonical_target) const {
-    GPR_ASSERT(uri != nullptr);
-    absl::StatusOr<URI> tmp_uri = URI::Parse(target);
-    ResolverFactory* factory =
-        tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
-    if (factory != nullptr) {
-      *uri = std::move(*tmp_uri);
-      return factory;
-    }
-    *canonical_target = absl::StrCat(default_prefix_.get(), target);
-    absl::StatusOr<URI> tmp_uri2 = URI::Parse(*canonical_target);
-    factory =
-        tmp_uri2.ok() ? LookupResolverFactory(tmp_uri2->scheme()) : nullptr;
-    if (factory != nullptr) {
-      *uri = std::move(*tmp_uri2);
-      return factory;
-    }
-    if (!tmp_uri.ok() || !tmp_uri2.ok()) {
-      gpr_log(GPR_ERROR, "%s",
-              absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
-                              tmp_uri.status().ToString(), *canonical_target,
-                              tmp_uri2.status().ToString())
-                  .c_str());
-      return nullptr;
-    }
-    gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
-            std::string(target).c_str(), canonical_target->c_str());
-    return nullptr;
-  }
-
- private:
-  // We currently support 10 factories without doing additional
-  // allocation.  This number could be raised if there is a case where
-  // more factories are needed and the additional allocations are
-  // hurting performance (which is unlikely, since these allocations
-  // only occur at gRPC initialization time).
-  absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
-  UniquePtr<char> default_prefix_;
-};
-
-RegistryState* g_state = nullptr;
+#include "src/core/lib/resolver/resolver_registry.h"
 
-}  // namespace
+namespace grpc_core {
 
 //
 // ResolverRegistry::Builder
 //
 
-void ResolverRegistry::Builder::InitRegistry() {
-  if (g_state == nullptr) g_state = new RegistryState();
+ResolverRegistry::Builder::Builder() { Reset(); }
+
+void ResolverRegistry::Builder::SetDefaultPrefix(std::string default_prefix) {
+  state_.default_prefix = std::move(default_prefix);
+}
+
+void ResolverRegistry::Builder::RegisterResolverFactory(
+    std::unique_ptr<ResolverFactory> factory) {
+  auto p = state_.factories.emplace(factory->scheme(), std::move(factory));
+  GPR_ASSERT(p.second);
 }
 
-void ResolverRegistry::Builder::ShutdownRegistry() {
-  delete g_state;
-  g_state = nullptr;
+bool ResolverRegistry::Builder::HasResolverFactory(
+    absl::string_view scheme) const {
+  return state_.factories.find(scheme) != state_.factories.end();
 }
 
-void ResolverRegistry::Builder::SetDefaultPrefix(const char* default_prefix) {
-  InitRegistry();
-  g_state->SetDefaultPrefix(default_prefix);
+void ResolverRegistry::Builder::Reset() {
+  state_.factories.clear();
+  state_.default_prefix = "dns:///";
 }
 
-void ResolverRegistry::Builder::RegisterResolverFactory(
-    std::unique_ptr<ResolverFactory> factory) {
-  InitRegistry();
-  g_state->RegisterResolverFactory(std::move(factory));
+ResolverRegistry ResolverRegistry::Builder::Build() {
+  return ResolverRegistry(std::move(state_));
 }
 
 //
 // ResolverRegistry
 //
 
-ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
-  GPR_ASSERT(g_state != nullptr);
-  return g_state->LookupResolverFactory(scheme);
-}
-
-bool ResolverRegistry::IsValidTarget(absl::string_view target) {
-  URI uri;
+bool ResolverRegistry::IsValidTarget(absl::string_view target) const {
   std::string canonical_target;
+  URI uri;
   ResolverFactory* factory =
-      g_state->FindResolverFactory(target, &uri, &canonical_target);
-  return factory == nullptr ? false : factory->IsValidUri(uri);
+      FindResolverFactory(target, &uri, &canonical_target);
+  if (factory == nullptr) return false;
+  return factory->IsValidUri(uri);
 }
 
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
-    const char* target, const grpc_channel_args* args,
+    absl::string_view target, const grpc_channel_args* args,
     grpc_pollset_set* pollset_set,
     std::shared_ptr<WorkSerializer> work_serializer,
-    std::unique_ptr<Resolver::ResultHandler> result_handler) {
-  GPR_ASSERT(g_state != nullptr);
+    std::unique_ptr<Resolver::ResultHandler> result_handler) const {
+  std::string canonical_target;
   ResolverArgs resolver_args;
-  ResolverFactory* factory = g_state->FindResolverFactory(
-      target, &resolver_args.uri, &resolver_args.uri_string);
+  ResolverFactory* factory =
+      FindResolverFactory(target, &resolver_args.uri, &canonical_target);
   if (factory == nullptr) return nullptr;
-  if (resolver_args.uri_string.empty()) resolver_args.uri_string = target;
   resolver_args.args = args;
   resolver_args.pollset_set = pollset_set;
   resolver_args.work_serializer = std::move(work_serializer);
@@ -171,25 +94,63 @@ OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
   return factory->CreateResolver(std::move(resolver_args));
 }
 
-std::string ResolverRegistry::GetDefaultAuthority(absl::string_view target) {
-  GPR_ASSERT(g_state != nullptr);
-  URI uri;
+std::string ResolverRegistry::GetDefaultAuthority(
+    absl::string_view target) const {
   std::string canonical_target;
+  URI uri;
   ResolverFactory* factory =
-      g_state->FindResolverFactory(target, &uri, &canonical_target);
-  std::string authority =
-      factory == nullptr ? "" : factory->GetDefaultAuthority(uri);
-  return authority;
+      FindResolverFactory(target, &uri, &canonical_target);
+  if (factory == nullptr) return "";
+  return factory->GetDefaultAuthority(uri);
 }
 
-UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(const char* target) {
-  GPR_ASSERT(g_state != nullptr);
-  URI uri;
+std::string ResolverRegistry::AddDefaultPrefixIfNeeded(
+    absl::string_view target) const {
   std::string canonical_target;
-  g_state->FindResolverFactory(target, &uri, &canonical_target);
-  return UniquePtr<char>(canonical_target.empty()
-                             ? gpr_strdup(target)
-                             : gpr_strdup(canonical_target.c_str()));
+  URI uri;
+  FindResolverFactory(target, &uri, &canonical_target);
+  return canonical_target.empty() ? std::string(target) : canonical_target;
+}
+
+ResolverFactory* ResolverRegistry::LookupResolverFactory(
+    absl::string_view scheme) const {
+  auto it = state_.factories.find(scheme);
+  if (it == state_.factories.end()) return nullptr;
+  return it->second.get();
+}
+
+// Returns the factory for the scheme of \a target.  If \a target does
+// not parse as a URI, prepends \a default_prefix_ and tries again.
+// If URI parsing is successful (in either attempt), sets \a uri to
+// point to the parsed URI.
+ResolverFactory* ResolverRegistry::FindResolverFactory(
+    absl::string_view target, URI* uri, std::string* canonical_target) const {
+  GPR_ASSERT(uri != nullptr);
+  absl::StatusOr<URI> tmp_uri = URI::Parse(target);
+  ResolverFactory* factory =
+      tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
+  if (factory != nullptr) {
+    *uri = std::move(*tmp_uri);
+    return factory;
+  }
+  *canonical_target = absl::StrCat(state_.default_prefix, target);
+  absl::StatusOr<URI> tmp_uri2 = URI::Parse(*canonical_target);
+  factory = tmp_uri2.ok() ? LookupResolverFactory(tmp_uri2->scheme()) : nullptr;
+  if (factory != nullptr) {
+    *uri = std::move(*tmp_uri2);
+    return factory;
+  }
+  if (!tmp_uri.ok() || !tmp_uri2.ok()) {
+    gpr_log(GPR_ERROR, "%s",
+            absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
+                            tmp_uri.status().ToString(), *canonical_target,
+                            tmp_uri2.status().ToString())
+                .c_str());
+    return nullptr;
+  }
+  gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
+          std::string(target).c_str(), canonical_target->c_str());
+  return nullptr;
 }
 
 }  // namespace grpc_core

data/src/core/lib/resolver/resolver_registry.h

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+// Copyright 2015 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_LIB_RESOLVER_RESOLVER_REGISTRY_H
 #define GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
@@ -28,29 +26,47 @@
 namespace grpc_core {
 
 class ResolverRegistry {
+ private:
+  // Forward declaration needed to use this in Builder.
+  struct State {
+    std::map<absl::string_view, std::unique_ptr<ResolverFactory>> factories;
+    std::string default_prefix;
+  };
+
  public:
   /// Methods used to create and populate the ResolverRegistry.
   /// NOT THREAD SAFE -- to be used only during global gRPC
   /// initialization and shutdown.
   class Builder {
    public:
-    /// Global initialization and shutdown hooks.
-    static void InitRegistry();
-    static void ShutdownRegistry();
+    Builder();
 
     /// Sets the default URI prefix to \a default_prefix.
-    /// Calls InitRegistry() if it has not already been called.
-    static void SetDefaultPrefix(const char* default_prefix);
+    void SetDefaultPrefix(std::string default_prefix);
 
     /// Registers a resolver factory.  The factory will be used to create a
     /// resolver for any URI whose scheme matches that of the factory.
-    /// Calls InitRegistry() if it has not already been called.
-    static void RegisterResolverFactory(
-        std::unique_ptr<ResolverFactory> factory);
+    void RegisterResolverFactory(std::unique_ptr<ResolverFactory> factory);
+
+    /// Returns true iff scheme already has a registered factory.
+    bool HasResolverFactory(absl::string_view scheme) const;
+
+    /// Wipe everything in the registry and reset to empty.
+    void Reset();
+
+    ResolverRegistry Build();
+
+   private:
+    ResolverRegistry::State state_;
   };
 
+  ResolverRegistry(const ResolverRegistry&) = delete;
+  ResolverRegistry& operator=(const ResolverRegistry&) = delete;
+  ResolverRegistry(ResolverRegistry&&) noexcept;
+  ResolverRegistry& operator=(ResolverRegistry&&) noexcept;
+
   /// Checks whether the user input \a target is valid to create a resolver.
-  static bool IsValidTarget(absl::string_view target);
+  bool IsValidTarget(absl::string_view target) const;
 
   /// Creates a resolver given \a target.
   /// First tries to parse \a target as a URI. If this succeeds, tries
@@ -65,23 +81,33 @@ class ResolverRegistry {
   /// name resolution process. \a work_serializer is the work_serializer under
   /// which all resolver calls will be run. \a result_handler is used to return
   /// results from the resolver.
-  static OrphanablePtr<Resolver> CreateResolver(
-      const char* target, const grpc_channel_args* args,
+  OrphanablePtr<Resolver> CreateResolver(
+      absl::string_view target, const grpc_channel_args* args,
       grpc_pollset_set* pollset_set,
       std::shared_ptr<WorkSerializer> work_serializer,
-      std::unique_ptr<Resolver::ResultHandler> result_handler);
+      std::unique_ptr<Resolver::ResultHandler> result_handler) const;
 
   /// Returns the default authority to pass from a client for \a target.
-  static std::string GetDefaultAuthority(absl::string_view target);
+  std::string GetDefaultAuthority(absl::string_view target) const;
 
   /// Returns \a target with the default prefix prepended, if needed.
-  static UniquePtr<char> AddDefaultPrefixIfNeeded(const char* target);
+  std::string AddDefaultPrefixIfNeeded(absl::string_view target) const;
 
   /// Returns the resolver factory for \a scheme.
   /// Caller does NOT own the return value.
-  static ResolverFactory* LookupResolverFactory(const char* scheme);
+  ResolverFactory* LookupResolverFactory(absl::string_view scheme) const;
+
+ private:
+  explicit ResolverRegistry(State state) : state_(std::move(state)) {}
+
+  // TODO(ctiller): fix callers such that the canonical_target argument can be
+  // removed, and replaced with uri.ToString().
+  ResolverFactory* FindResolverFactory(absl::string_view target, URI* uri,
+                                       std::string* canonical_target) const;
+
+  State state_;
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H */
+#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H