grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/lib/channel/channelz.cc

@@ -20,12 +20,9 @@
 
 #include "src/core/lib/channel/channelz.h"
 
-#include <stdlib.h>
-
 #include <algorithm>
 #include <atomic>
 #include <memory>
-#include <type_traits>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
@@ -42,10 +39,7 @@
 #include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -424,42 +418,38 @@ namespace {
 void PopulateSocketAddressJson(Json::Object* json, const char* name,
                                const char* addr_str) {
   if (addr_str == nullptr) return;
-  Json::Object data;
   absl::StatusOr<URI> uri = URI::Parse(addr_str);
-  if (uri.ok() && (uri->scheme() == "ipv4" || uri->scheme() == "ipv6")) {
-    std::string host;
-    std::string port;
-    GPR_ASSERT(
-        SplitHostPort(absl::StripPrefix(uri->path(), "/"), &host, &port));
-    int port_num = -1;
-    if (!port.empty()) {
-      port_num = atoi(port.data());
-    }
-    grpc_resolved_address resolved_host;
-    grpc_error_handle error =
-        grpc_string_to_sockaddr(&resolved_host, host.c_str(), port_num);
-    if (GRPC_ERROR_IS_NONE(error)) {
-      std::string packed_host = grpc_sockaddr_get_packed_host(&resolved_host);
-      std::string b64_host = absl::Base64Escape(packed_host);
-      data["tcpip_address"] = Json::Object{
-          {"port", port_num},
-          {"ip_address", b64_host},
+  if (uri.ok()) {
+    if (uri->scheme() == "ipv4" || uri->scheme() == "ipv6") {
+      auto address = StringToSockaddr(absl::StripPrefix(uri->path(), "/"));
+      if (address.ok()) {
+        std::string packed_host = grpc_sockaddr_get_packed_host(&*address);
+        (*json)[name] = Json::Object{
+            {"tcpip_address",
+             Json::Object{
+                 {"port", grpc_sockaddr_get_port(&*address)},
+                 {"ip_address", absl::Base64Escape(packed_host)},
+             }},
+        };
+        return;
+      }
+    } else if (uri->scheme() == "unix") {
+      (*json)[name] = Json::Object{
+          {"uds_address",
+           Json::Object{
+               {"filename", uri->path()},
+           }},
       };
-      (*json)[name] = std::move(data);
       return;
     }
-    GRPC_ERROR_UNREF(error);
-  }
-  if (uri.ok() && uri->scheme() == "unix") {
-    data["uds_address"] = Json::Object{
-        {"filename", uri->path()},
-    };
-  } else {
-    data["other_address"] = Json::Object{
-        {"name", addr_str},
-    };
   }
-  (*json)[name] = std::move(data);
+  // Unknown address type.
+  (*json)[name] = Json::Object{
+      {"other_address",
+       Json::Object{
+           {"name", addr_str},
+       }},
+  };
 }
 
 }  // namespace

data/src/core/lib/channel/channelz.h

@@ -40,6 +40,7 @@
 
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -303,6 +304,14 @@ class SocketNode : public BaseNode {
 
     Json RenderJson();
 
+    static absl::string_view ChannelArgName() {
+      return GRPC_ARG_CHANNELZ_SECURITY;
+    }
+
+    static int ChannelArgsCompare(const Security* a, const Security* b) {
+      return QsortCompare(a, b);
+    }
+
     grpc_arg MakeChannelArg() const;
 
     static RefCountedPtr<Security> GetFromChannelArgs(

data/src/core/lib/channel/promise_based_filter.h

@@ -26,7 +26,6 @@
 
 #include <atomic>
 #include <new>
-#include <type_traits>
 #include <utility>
 
 #include "absl/container/inlined_vector.h"

data/src/core/lib/config/core_configuration.h

@@ -20,6 +20,8 @@
 #include <atomic>
 #include <functional>
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
@@ -76,6 +78,50 @@ class CoreConfiguration {
     CoreConfiguration* Build();
   };
 
+  // Stores a builder for RegisterBuilder
+  struct RegisteredBuilder {
+    std::function<void(Builder*)> builder;
+    RegisteredBuilder* next;
+  };
+
+  // Temporarily replaces core configuration with what is built from the
+  // provided BuildFunc that takes (Builder*) and returns void.
+  // Requires no concurrent Get() be called. Restores current core
+  // configuration when this object is destroyed. The default builder
+  // is not backed up or restored.
+  //
+  // Useful for running multiple tests back to back in the same process
+  // without side effects from previous tests.
+  class WithSubstituteBuilder {
+   public:
+    template <typename BuildFunc>
+    explicit WithSubstituteBuilder(BuildFunc build) {
+      // Build core configuration to replace.
+      Builder builder;
+      build(&builder);
+      CoreConfiguration* p = builder.Build();
+
+      // Backup current core configuration and replace/reset.
+      config_restore_ =
+          CoreConfiguration::config_.exchange(p, std::memory_order_acquire);
+      builders_restore_ = CoreConfiguration::builders_.exchange(
+          nullptr, std::memory_order_acquire);
+    }
+
+    ~WithSubstituteBuilder() {
+      // Reset and restore.
+      Reset();
+      GPR_ASSERT(CoreConfiguration::config_.exchange(
+                     config_restore_, std::memory_order_acquire) == nullptr);
+      GPR_ASSERT(CoreConfiguration::builders_.exchange(
+                     builders_restore_, std::memory_order_acquire) == nullptr);
+    }
+
+   private:
+    CoreConfiguration* config_restore_;
+    RegisteredBuilder* builders_restore_;
+  };
+
   // Lifetime methods
 
   // Get the core configuration; if it does not exist, create it.
@@ -87,36 +133,11 @@ class CoreConfiguration {
     return BuildNewAndMaybeSet();
   }
 
-  // Build a special core configuration.
-  // Requires no concurrent Get() be called.
-  // Doesn't call the regular BuildCoreConfiguration function, instead calls
-  // `build`.
-  // BuildFunc is a callable that takes a Builder* and returns void.
-  // We use a template instead of std::function<void(Builder*)> to avoid
-  // including std::function in this widely used header, and to ensure no code
-  // is generated in programs that do not use this function.
-  // This is sometimes useful for testing.
-  template <typename BuildFunc>
-  static void BuildSpecialConfiguration(BuildFunc build) {
-    // Build bespoke configuration
-    Builder builder;
-    build(&builder);
-    CoreConfiguration* p = builder.Build();
-    // Swap in final configuration, deleting anything that was already present.
-    delete config_.exchange(p, std::memory_order_release);
-  }
-
   // Attach a registration function globally.
   // Each registration function is called *in addition to*
-  // BuildCoreConfiguration for the default core configuration. When using
-  // BuildSpecialConfiguration, one can use CallRegisteredBuilders to call them.
-  // Must be called before a configuration is built.
+  // BuildCoreConfiguration for the default core configuration.
   static void RegisterBuilder(std::function<void(Builder*)> builder);
 
-  // Call all registered builders.
-  // See RegisterBuilder for why you might want to call this.
-  static void CallRegisteredBuilders(Builder* builder);
-
   // Drop the core configuration. Users must ensure no other threads are
   // accessing the configuration.
   // Clears any dynamically registered builders.
@@ -128,10 +149,8 @@ class CoreConfiguration {
   template <typename BuildFunc, typename RunFunc>
   static void RunWithSpecialConfiguration(BuildFunc build_configuration,
                                           RunFunc code_to_run) {
-    Reset();
-    BuildSpecialConfiguration(build_configuration);
+    WithSubstituteBuilder builder(build_configuration);
     code_to_run();
-    Reset();
   }
 
   // Accessors
@@ -165,12 +184,6 @@ class CoreConfiguration {
  private:
   explicit CoreConfiguration(Builder* builder);
 
-  // Stores a builder for RegisterBuilder
-  struct RegisteredBuilder {
-    std::function<void(Builder*)> builder;
-    RegisteredBuilder* next;
-  };
-
   // Create a new CoreConfiguration, and either set it or throw it away.
   // We allow multiple CoreConfiguration's to be created in parallel.
   static const CoreConfiguration& BuildNewAndMaybeSet();

data/src/core/lib/debug/stats.cc

@@ -31,30 +31,27 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
-#include <grpc/support/sync.h>
 
-grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
-static size_t g_num_cores;
-static gpr_once g_once = GPR_ONCE_INIT;
-
-void grpc_stats_init(void) {
-  gpr_once_init(&g_once, []() {
-    g_num_cores = gpr_cpu_num_cores();
-    grpc_stats_per_cpu_storage = static_cast<grpc_stats_data*>(
-        gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores));
-  });
-}
+namespace grpc_core {
+Stats* const g_stats_data = [] {
+  size_t num_cores = gpr_cpu_num_cores();
+  Stats* stats = static_cast<Stats*>(
+      gpr_zalloc(sizeof(Stats) + num_cores * sizeof(grpc_stats_data)));
+  stats->num_cores = num_cores;
+  return stats;
+}();
+}  // namespace grpc_core
 
 void grpc_stats_collect(grpc_stats_data* output) {
   memset(output, 0, sizeof(*output));
-  for (size_t core = 0; core < g_num_cores; core++) {
+  for (size_t core = 0; core < grpc_core::g_stats_data->num_cores; core++) {
     for (size_t i = 0; i < GRPC_STATS_COUNTER_COUNT; i++) {
       output->counters[i] += gpr_atm_no_barrier_load(
-          &grpc_stats_per_cpu_storage[core].counters[i]);
+          &grpc_core::g_stats_data->per_cpu[core].counters[i]);
     }
     for (size_t i = 0; i < GRPC_STATS_HISTOGRAM_BUCKETS; i++) {
       output->histograms[i] += gpr_atm_no_barrier_load(
-          &grpc_stats_per_cpu_storage[core].histograms[i]);
+          &grpc_core::g_stats_data->per_cpu[core].histograms[i]);
     }
   }
 }

data/src/core/lib/debug/stats.h

@@ -35,10 +35,17 @@ typedef struct grpc_stats_data {
   gpr_atm histograms[GRPC_STATS_HISTOGRAM_BUCKETS];
 } grpc_stats_data;
 
-extern grpc_stats_data* grpc_stats_per_cpu_storage;
+namespace grpc_core {
+struct Stats {
+  size_t num_cores;
+  grpc_stats_data per_cpu[0];
+};
+extern Stats* const g_stats_data;
+}  // namespace grpc_core
 
 #define GRPC_THREAD_STATS_DATA() \
-  (&grpc_stats_per_cpu_storage[grpc_core::ExecCtx::Get()->starting_cpu()])
+  (&::grpc_core::g_stats_data    \
+        ->per_cpu[grpc_core::ExecCtx::Get()->starting_cpu()])
 
 /* Only collect stats if GRPC_COLLECT_STATS is defined or it is a debug build.
  */
@@ -55,7 +62,8 @@ extern grpc_stats_data* grpc_stats_per_cpu_storage;
 #define GRPC_STATS_INC_HISTOGRAM(histogram, index)
 #endif /* defined(GRPC_COLLECT_STATS) || !defined(NDEBUG) */
 
-void grpc_stats_init(void);
+GRPC_DEPRECATED("function is no longer needed")
+inline void grpc_stats_init(void) {}
 void grpc_stats_collect(grpc_stats_data* output);
 // c = b-a
 void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,

data/src/core/lib/event_engine/{event_engine.cc → default_event_engine.cc}

@@ -13,28 +13,32 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/event_engine/default_event_engine.h"
+
 #include <atomic>
-#include <functional>
 #include <memory>
 #include <utility>
 
+#include "absl/functional/any_invocable.h"
+
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/event_engine/default_event_engine_factory.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 namespace {
-std::atomic<const std::function<std::unique_ptr<EventEngine>()>*>
+std::atomic<absl::AnyInvocable<std::unique_ptr<EventEngine>()>*>
     g_event_engine_factory{nullptr};
 std::atomic<EventEngine*> g_event_engine{nullptr};
 }  // namespace
 
 void SetDefaultEventEngineFactory(
-    std::function<std::unique_ptr<EventEngine>()> factory) {
+    absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory) {
   delete g_event_engine_factory.exchange(
-      new std::function<std::unique_ptr<EventEngine>()>(std::move(factory)));
+      new absl::AnyInvocable<std::unique_ptr<EventEngine>()>(
+          std::move(factory)));
 }
 
 std::unique_ptr<EventEngine> CreateEventEngine() {

data/src/core/lib/event_engine/{event_engine_factory.h → default_event_engine.h}

@@ -11,12 +11,11 @@
 // 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_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
 
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H
 
-#include <memory>
+#include <grpc/support/port_platform.h>
 
 #include <grpc/event_engine/event_engine.h>
 
@@ -29,13 +28,10 @@ namespace experimental {
 /// Strongly consider whether you could use \a CreateEventEngine instead.
 EventEngine* GetDefaultEventEngine();
 
-/// Create an EventEngine using the default factory provided at link time.
-std::unique_ptr<EventEngine> DefaultEventEngineFactory();
-
 /// Reset the default event engine
 void ResetDefaultEventEngine();
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H

data/src/core/lib/event_engine/default_event_engine_factory.cc

@@ -11,23 +11,40 @@
 // 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/lib/event_engine/default_event_engine_factory.h"
+
 #include <memory>
 
 #include "absl/memory/memory.h"
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/event_engine_factory.h"
-#include "src/core/lib/event_engine/iomgr_engine/iomgr_engine.h"
+#ifdef GPR_WINDOWS
+#include "src/core/lib/event_engine/windows/windows_engine.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
+  return absl::make_unique<WindowsEventEngine>();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+#else  // not GPR_WINDOWS
+#include "src/core/lib/event_engine/posix_engine/posix_engine.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return absl::make_unique<IomgrEventEngine>();
+  return absl::make_unique<PosixEventEngine>();
 }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
+
+#endif

data/src/core/lib/event_engine/default_event_engine_factory.h

@@ -0,0 +1,33 @@
+// Copyright 2021 The 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_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Create an EventEngine using the default factory provided at link time.
+std::unique_ptr<EventEngine> DefaultEventEngineFactory();
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H

data/src/core/lib/event_engine/executor/executor.h

@@ -0,0 +1,38 @@
+// Copyright 2022 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_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A subset of the EventEngine execution API. See event_engine.h for details
+class Executor {
+ public:
+  virtual ~Executor() = default;
+  virtual void Run(EventEngine::Closure* closure) = 0;
+  virtual void Run(absl::AnyInvocable<void()> closure) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H

data/src/core/lib/event_engine/executor/threaded_executor.cc

@@ -0,0 +1,36 @@
+// Copyright 2022 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/lib/event_engine/executor/threaded_executor.h"
+
+#include <utility>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+ThreadedExecutor::ThreadedExecutor(int reserve_threads)
+    : thread_pool_(reserve_threads){};
+
+void ThreadedExecutor::Run(EventEngine::Closure* closure) {
+  thread_pool_.Add([closure]() { closure->Run(); });
+}
+
+void ThreadedExecutor::Run(absl::AnyInvocable<void()> closure) {
+  thread_pool_.Add(std::move(closure));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/executor/threaded_executor.h

@@ -0,0 +1,44 @@
+// Copyright 2022 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_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/executor/executor.h"
+#include "src/core/lib/event_engine/thread_pool.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class ThreadedExecutor : public Executor {
+ public:
+  explicit ThreadedExecutor(int reserve_threads);
+  ~ThreadedExecutor() override = default;
+  void Run(EventEngine::Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+
+ private:
+  ThreadPool thread_pool_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H