grpc 1.48.0-x86_64-linux → 1.49.1-x86_64-linux

data/src/core/{ext/filters/client_channel → lib/load_balancing}/lb_policy_registry.cc

@@ -1,26 +1,22 @@
-/*
- *
- * 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>
 
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-
-#include <string.h>
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
 
 #include <algorithm>
 #include <map>
@@ -28,6 +24,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
@@ -41,30 +38,24 @@ namespace {
 
 class RegistryState {
  public:
-  RegistryState() {}
-
   void RegisterLoadBalancingPolicyFactory(
       std::unique_ptr<LoadBalancingPolicyFactory> factory) {
     gpr_log(GPR_DEBUG, "registering LB policy factory for \"%s\"",
-            factory->name());
-    for (size_t i = 0; i < factories_.size(); ++i) {
-      GPR_ASSERT(strcmp(factories_[i]->name(), factory->name()) != 0);
-    }
-    factories_.push_back(std::move(factory));
+            std::string(factory->name()).c_str());
+    GPR_ASSERT(factories_.find(factory->name()) == factories_.end());
+    factories_.emplace(factory->name(), std::move(factory));
   }
 
   LoadBalancingPolicyFactory* GetLoadBalancingPolicyFactory(
-      const char* name) const {
-    for (size_t i = 0; i < factories_.size(); ++i) {
-      if (strcmp(name, factories_[i]->name()) == 0) {
-        return factories_[i].get();
-      }
-    }
-    return nullptr;
+      absl::string_view name) const {
+    auto it = factories_.find(name);
+    if (it == factories_.end()) return nullptr;
+    return it->second.get();
   }
 
  private:
-  std::vector<std::unique_ptr<LoadBalancingPolicyFactory>> factories_;
+  std::map<absl::string_view, std::unique_ptr<LoadBalancingPolicyFactory>>
+      factories_;
 };
 
 RegistryState* g_state = nullptr;
@@ -96,7 +87,7 @@ void LoadBalancingPolicyRegistry::Builder::RegisterLoadBalancingPolicyFactory(
 
 OrphanablePtr<LoadBalancingPolicy>
 LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-    const char* name, LoadBalancingPolicy::Args args) {
+    absl::string_view name, LoadBalancingPolicy::Args args) {
   GPR_ASSERT(g_state != nullptr);
   // Find factory.
   LoadBalancingPolicyFactory* factory =
@@ -107,18 +98,14 @@ LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
 }
 
 bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-    const char* name, bool* requires_config) {
+    absl::string_view name, bool* requires_config) {
   GPR_ASSERT(g_state != nullptr);
   auto* factory = g_state->GetLoadBalancingPolicyFactory(name);
-  if (factory == nullptr) {
-    return false;
-  }
+  if (factory == nullptr) return false;
+  // If requested, check if the load balancing policy allows an empty config.
   if (requires_config != nullptr) {
-    grpc_error_handle error = GRPC_ERROR_NONE;
-    // Check if the load balancing policy allows an empty config
-    *requires_config =
-        factory->ParseLoadBalancingConfig(Json(), &error) == nullptr;
-    GRPC_ERROR_UNREF(error);
+    auto config = factory->ParseLoadBalancingConfig(Json());
+    *requires_config = !config.ok();
   }
   return true;
 }
@@ -127,64 +114,54 @@ namespace {
 
 // Returns the JSON node of policy (with both policy name and config content)
 // given the JSON node of a LoadBalancingConfig array.
-grpc_error_handle ParseLoadBalancingConfigHelper(
-    const Json& lb_config_array, Json::Object::const_iterator* result) {
+absl::StatusOr<Json::Object::const_iterator> ParseLoadBalancingConfigHelper(
+    const Json& lb_config_array) {
   if (lb_config_array.type() != Json::Type::ARRAY) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("type should be array");
+    return absl::InvalidArgumentError("type should be array");
   }
   // Find the first LB policy that this client supports.
   std::vector<absl::string_view> policies_tried;
   for (const Json& lb_config : lb_config_array.array_value()) {
     if (lb_config.type() != Json::Type::OBJECT) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "child entry should be of type object");
+      return absl::InvalidArgumentError("child entry should be of type object");
     }
     if (lb_config.object_value().empty()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "no policy found in child entry");
+      return absl::InvalidArgumentError("no policy found in child entry");
     }
     if (lb_config.object_value().size() > 1) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("oneOf violation");
+      return absl::InvalidArgumentError("oneOf violation");
     }
     auto it = lb_config.object_value().begin();
     if (it->second.type() != Json::Type::OBJECT) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "child entry should be of type object");
+      return absl::InvalidArgumentError("child entry should be of type object");
     }
     // If we support this policy, then select it.
     if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
             it->first.c_str(), nullptr)) {
-      *result = it;
-      return GRPC_ERROR_NONE;
+      return it;
     }
     policies_tried.push_back(it->first);
   }
-  return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+  return absl::FailedPreconditionError(absl::StrCat(
       "No known policies in list: ", absl::StrJoin(policies_tried, " ")));
 }
 
 }  // namespace
 
-RefCountedPtr<LoadBalancingPolicy::Config>
-LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-    const Json& json, grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
+absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const Json& json) {
   GPR_ASSERT(g_state != nullptr);
-  Json::Object::const_iterator policy;
-  *error = ParseLoadBalancingConfigHelper(json, &policy);
-  if (!GRPC_ERROR_IS_NONE(*error)) {
-    return nullptr;
-  }
+  auto policy = ParseLoadBalancingConfigHelper(json);
+  if (!policy.ok()) return policy.status();
   // Find factory.
   LoadBalancingPolicyFactory* factory =
-      g_state->GetLoadBalancingPolicyFactory(policy->first.c_str());
+      g_state->GetLoadBalancingPolicyFactory((*policy)->first.c_str());
   if (factory == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrFormat("Factory not found for policy \"%s\"", policy->first));
-    return nullptr;
+    return absl::FailedPreconditionError(absl::StrFormat(
+        "Factory not found for policy \"%s\"", (*policy)->first));
   }
   // Parse load balancing config via factory.
-  return factory->ParseLoadBalancingConfig(policy->second, error);
+  return factory->ParseLoadBalancingConfig((*policy)->second);
 }
 
 }  // namespace grpc_core

data/src/core/{ext/filters/client_channel → lib/load_balancing}/lb_policy_registry.h

@@ -1,34 +1,34 @@
-/*
- *
- * 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_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_REGISTRY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_REGISTRY_H
+#ifndef GRPC_CORE_LIB_LOAD_BALANCING_LB_POLICY_REGISTRY_H
+#define GRPC_CORE_LIB_LOAD_BALANCING_LB_POLICY_REGISTRY_H
 
 #include <grpc/support/port_platform.h>
 
 #include <memory>
 
-#include "src/core/ext/filters/client_channel/lb_policy.h"
-#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/load_balancing/lb_policy_factory.h"
 
 namespace grpc_core {
 
@@ -51,20 +51,20 @@ class LoadBalancingPolicyRegistry {
 
   /// Creates an LB policy of the type specified by \a name.
   static OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
-      const char* name, LoadBalancingPolicy::Args args);
+      absl::string_view name, LoadBalancingPolicy::Args args);
 
   /// Returns true if the LB policy factory specified by \a name exists in this
   /// registry. If the load balancing policy requires a config to be specified
   /// then sets \a requires_config to true.
-  static bool LoadBalancingPolicyExists(const char* name,
+  static bool LoadBalancingPolicyExists(absl::string_view name,
                                         bool* requires_config);
 
   /// Returns a parsed object of the load balancing policy to be used from a
   /// LoadBalancingConfig array \a json.
-  static RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const Json& json, grpc_error_handle* error);
+  static absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseLoadBalancingConfig(const Json& json);
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_REGISTRY_H */
+#endif  // GRPC_CORE_LIB_LOAD_BALANCING_LB_POLICY_REGISTRY_H

data/src/core/{ext/filters/client_channel → lib/load_balancing}/subchannel_interface.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
+#ifndef GRPC_CORE_LIB_LOAD_BALANCING_SUBCHANNEL_INTERFACE_H
+#define GRPC_CORE_LIB_LOAD_BALANCING_SUBCHANNEL_INTERFACE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,8 +25,8 @@
 #include "absl/status/status.h"
 
 #include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -98,7 +98,7 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
       std::unique_ptr<DataWatcherInterface> watcher) = 0;
 
   // TODO(roth): Need a better non-grpc-specific abstraction here.
-  virtual const grpc_channel_args* channel_args() = 0;
+  virtual ChannelArgs channel_args() = 0;
 };
 
 // A class that delegates to another subchannel, to be used in cases
@@ -124,7 +124,7 @@ class DelegatingSubchannel : public SubchannelInterface {
     wrapped_subchannel_->RequestConnection();
   }
   void ResetBackoff() override { wrapped_subchannel_->ResetBackoff(); }
-  const grpc_channel_args* channel_args() override {
+  ChannelArgs channel_args() override {
     return wrapped_subchannel_->channel_args();
   }
   void AddDataWatcher(std::unique_ptr<DataWatcherInterface> watcher) override {
@@ -137,4 +137,4 @@ class DelegatingSubchannel : public SubchannelInterface {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
+#endif  // GRPC_CORE_LIB_LOAD_BALANCING_SUBCHANNEL_INTERFACE_H

data/src/core/lib/promise/activity.h

@@ -34,6 +34,7 @@
 
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/promise/context.h"
@@ -56,15 +57,25 @@ class Wakeable {
   inline ~Wakeable() {}
 };
 
+namespace activity_detail {
+struct Unwakeable final : public Wakeable {
+  void Wakeup() override {}
+  void Drop() override {}
+};
+static Unwakeable* unwakeable() {
+  return NoDestructSingleton<Unwakeable>::Get();
+}
+}  // namespace activity_detail
+
+class AtomicWaker;
+
 // An owning reference to a Wakeable.
 // This type is non-copyable but movable.
 class Waker {
  public:
   explicit Waker(Wakeable* wakeable) : wakeable_(wakeable) {}
-  Waker() : Waker(nullptr) {}
-  ~Waker() {
-    if (wakeable_ != nullptr) wakeable_->Drop();
-  }
+  Waker() : Waker(activity_detail::unwakeable()) {}
+  ~Waker() { wakeable_->Drop(); }
   Waker(const Waker&) = delete;
   Waker& operator=(const Waker&) = delete;
   Waker(Waker&& other) noexcept : wakeable_(other.Take()) {}
@@ -74,9 +85,7 @@ class Waker {
   }
 
   // Wake the underlying activity.
-  void Wakeup() {
-    if (auto* wakeable = Take()) wakeable->Wakeup();
-  }
+  void Wakeup() { Take()->Wakeup(); }
 
   template <typename H>
   friend H AbslHashValue(H h, const Waker& w) {
@@ -88,11 +97,50 @@ class Waker {
   }
 
  private:
-  Wakeable* Take() { return absl::exchange(wakeable_, nullptr); }
+  friend class AtomicWaker;
+
+  Wakeable* Take() {
+    return absl::exchange(wakeable_, activity_detail::unwakeable());
+  }
 
   Wakeable* wakeable_;
 };
 
+// An atomic variant of Waker - this type is non-copyable and non-movable.
+class AtomicWaker {
+ public:
+  explicit AtomicWaker(Wakeable* wakeable) : wakeable_(wakeable) {}
+  AtomicWaker() : AtomicWaker(activity_detail::unwakeable()) {}
+  explicit AtomicWaker(Waker waker) : AtomicWaker(waker.Take()) {}
+  ~AtomicWaker() { wakeable_.load(std::memory_order_acquire)->Drop(); }
+  AtomicWaker(const AtomicWaker&) = delete;
+  AtomicWaker& operator=(const AtomicWaker&) = delete;
+  AtomicWaker(AtomicWaker&& other) noexcept = delete;
+  AtomicWaker& operator=(AtomicWaker&& other) noexcept = delete;
+
+  // Wake the underlying activity.
+  void Wakeup() { Take()->Wakeup(); }
+
+  // Return true if there is a not-unwakeable wakeable present.
+  bool Armed() const noexcept {
+    return wakeable_.load(std::memory_order_relaxed) !=
+           activity_detail::unwakeable();
+  }
+
+  // Set to some new waker
+  void Set(Waker waker) {
+    wakeable_.exchange(waker.Take(), std::memory_order_acq_rel)->Wakeup();
+  }
+
+ private:
+  Wakeable* Take() {
+    return wakeable_.exchange(activity_detail::unwakeable(),
+                              std::memory_order_acq_rel);
+  }
+
+  std::atomic<Wakeable*> wakeable_;
+};
+
 // An Activity tracks execution of a single promise.
 // It executes the promise under a mutex.
 // When the promise stalls, it registers the containing activity to be woken up