grpc 1.38.0 → 1.40.0

data/src/core/lib/iomgr/event_engine/timer.cc

@@ -0,0 +1,57 @@
+// 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.
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/event_engine/closure.h"
+#include "src/core/lib/iomgr/event_engine/iomgr.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/surface/init.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace {
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::GrpcClosureToCallback;
+
+void timer_init(grpc_timer* timer, grpc_millis deadline,
+                grpc_closure* closure) {
+  timer->ee_task_handle = grpc_iomgr_event_engine()->RunAt(
+      grpc_core::ToAbslTime(
+          grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME)),
+      GrpcClosureToCallback(closure, GRPC_ERROR_NONE), {});
+}
+
+void timer_cancel(grpc_timer* timer) {
+  auto handle = timer->ee_task_handle;
+  grpc_iomgr_event_engine()->TryCancel(handle);
+}
+
+/* Internal API */
+grpc_timer_check_result timer_check(grpc_millis* /* next */) {
+  return GRPC_TIMERS_NOT_CHECKED;
+}
+void timer_list_init() {}
+void timer_list_shutdown(void) {}
+void timer_consume_kick(void) {}
+
+}  // namespace
+
+grpc_timer_vtable grpc_event_engine_timer_vtable = {
+    timer_init,      timer_cancel,        timer_check,
+    timer_list_init, timer_list_shutdown, timer_consume_kick};
+
+#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/exec_ctx.cc

@@ -20,11 +20,14 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/event_engine/closure.h"
+#include "src/core/lib/iomgr/event_engine/iomgr.h"
 #include "src/core/lib/profiling/timers.h"
 
 static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
@@ -47,8 +50,13 @@ static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
 }
 
 static void exec_ctx_sched(grpc_closure* closure, grpc_error_handle error) {
+#if defined(GRPC_USE_EVENT_ENGINE) && \
+    defined(GRPC_EVENT_ENGINE_REPLACE_EXEC_CTX)
+  grpc_iomgr_event_engine()->Run(GrpcClosureToCallback(closure, error), {});
+#else
   grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure,
                            error);
+#endif
 }
 
 static gpr_timespec g_start_time;

data/src/core/lib/iomgr/exec_ctx.h

@@ -349,8 +349,7 @@ class ApplicationCallbackExecCtx {
     }
   }
 
-  static void Enqueue(grpc_experimental_completion_queue_functor* functor,
-                      int is_success) {
+  static void Enqueue(grpc_completion_queue_functor* functor, int is_success) {
     functor->internal_success = is_success;
     functor->internal_next = nullptr;
 
@@ -375,8 +374,8 @@ class ApplicationCallbackExecCtx {
 
  private:
   uintptr_t flags_{0u};
-  grpc_experimental_completion_queue_functor* head_{nullptr};
-  grpc_experimental_completion_queue_functor* tail_{nullptr};
+  grpc_completion_queue_functor* head_{nullptr};
+  grpc_completion_queue_functor* tail_{nullptr};
   GPR_TLS_CLASS_DECL(callback_exec_ctx_);
 };
 }  // namespace grpc_core

data/src/core/lib/iomgr/executor/threadpool.cc

@@ -41,8 +41,7 @@ void ThreadPoolWorker::Run() {
       break;
     }
     // Runs closure
-    auto* closure =
-        static_cast<grpc_experimental_completion_queue_functor*>(elem);
+    auto* closure = static_cast<grpc_completion_queue_functor*>(elem);
     closure->functor_run(closure, closure->internal_success);
   }
 }
@@ -120,7 +119,7 @@ ThreadPool::~ThreadPool() {
   delete queue_;
 }
 
-void ThreadPool::Add(grpc_experimental_completion_queue_functor* closure) {
+void ThreadPool::Add(grpc_completion_queue_functor* closure) {
   AssertHasNotBeenShutDown();
   queue_->Put(static_cast<void*>(closure));
 }

data/src/core/lib/iomgr/executor/threadpool.h

@@ -43,7 +43,7 @@ class ThreadPoolInterface {
   // current thread to be blocked (in case of unable to schedule).
   // Closure should contain a function pointer and arguments it will take, more
   // details for closure struct at /grpc/include/grpc/impl/codegen/grpc_types.h
-  virtual void Add(grpc_experimental_completion_queue_functor* closure) = 0;
+  virtual void Add(grpc_completion_queue_functor* closure) = 0;
 
   // Returns the current number of pending closures
   virtual int num_pending_closures() const = 0;
@@ -120,7 +120,7 @@ class ThreadPool : public ThreadPoolInterface {
 
   // Adds given closure into pending queue immediately. Since closure queue has
   // infinite length, this routine will not block.
-  void Add(grpc_experimental_completion_queue_functor* closure) override;
+  void Add(grpc_completion_queue_functor* closure) override;
 
   int num_pending_closures() const override;
   int pool_capacity() const override;

data/src/core/lib/iomgr/iomgr.cc

@@ -94,7 +94,6 @@ void grpc_iomgr_shutdown() {
   {
     grpc_timer_manager_shutdown();
     grpc_iomgr_platform_flush();
-    grpc_core::Executor::ShutdownAll();
 
     gpr_mu_lock(&g_mu);
     g_shutdown = 1;
@@ -149,6 +148,7 @@ void grpc_iomgr_shutdown() {
     gpr_mu_unlock(&g_mu);
     grpc_timer_list_shutdown();
     grpc_core::ExecCtx::Get()->Flush();
+    grpc_core::Executor::ShutdownAll();
   }
 
   /* ensure all threads have left g_mu */

data/src/core/lib/iomgr/iomgr_posix.cc

@@ -41,11 +41,13 @@ extern grpc_address_resolver_vtable grpc_posix_resolver_vtable;
 static void iomgr_platform_init(void) {
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
+  grpc_tcp_posix_init();
 }
 
 static void iomgr_platform_flush(void) {}
 
 static void iomgr_platform_shutdown(void) {
+  grpc_tcp_posix_shutdown();
   grpc_event_engine_shutdown();
   grpc_wakeup_fd_global_destroy();
 }

data/src/core/lib/iomgr/iomgr_posix_cfstream.cc

@@ -84,7 +84,43 @@ static grpc_iomgr_platform_vtable apple_vtable = {
     apple_iomgr_platform_is_any_background_poller_thread,
     apple_iomgr_platform_add_closure_to_background_poller};
 
+namespace {
+struct CFStreamEnv {
+  bool enable_cfstream;
+  bool enable_cfstream_run_loop;
+};
+
+// Parses environment variables for CFStream specific settings
+CFStreamEnv ParseEnvForCFStream() {
+  CFStreamEnv env;
+  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
+  env.enable_cfstream =
+      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
+  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
+  // CFStream run-loop is disabled by default. The user has to enable it
+  // explicitly with environment variable.
+  env.enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
+                                 enable_cfstream_run_loop_str[0] == '1';
+  return env;
+}
+
+void MaybeInitializeTcpPosix(void) {
+  CFStreamEnv env = ParseEnvForCFStream();
+  if (!env.enable_cfstream || !env.enable_cfstream_run_loop) {
+    grpc_tcp_posix_init();
+  }
+}
+
+void MaybeShutdownTcpPosix(void) {
+  CFStreamEnv env = ParseEnvForCFStream();
+  if (!env.enable_cfstream || !env.enable_cfstream_run_loop) {
+    grpc_tcp_posix_shutdown();
+  }
+}
+}  // namespace
+
 static void iomgr_platform_init(void) {
+  MaybeInitializeTcpPosix();
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
 }
@@ -94,6 +130,7 @@ static void iomgr_platform_flush(void) {}
 static void iomgr_platform_shutdown(void) {
   grpc_event_engine_shutdown();
   grpc_wakeup_fd_global_destroy();
+  MaybeShutdownTcpPosix();
 }
 
 static void iomgr_platform_shutdown_background_closure(void) {
@@ -118,22 +155,15 @@ static grpc_iomgr_platform_vtable vtable = {
     iomgr_platform_add_closure_to_background_poller};
 
 void grpc_set_default_iomgr_platform() {
-  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
-  bool enable_cfstream =
-      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
-  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
-  // CFStream run-loop is disabled by default. The user has to enable it
-  // explicitly with environment variable.
-  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
-                                  enable_cfstream_run_loop_str[0] == '1';
-  if (!enable_cfstream) {
+  CFStreamEnv env = ParseEnvForCFStream();
+  if (!env.enable_cfstream) {
     // Use POSIX sockets for both client and server
     grpc_set_tcp_client_impl(&grpc_posix_tcp_client_vtable);
     grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
     grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
     grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
     grpc_set_iomgr_platform_vtable(&vtable);
-  } else if (enable_cfstream && !enable_cfstream_run_loop) {
+  } else if (env.enable_cfstream && !env.enable_cfstream_run_loop) {
     // Use CFStream with dispatch queue for client; use POSIX sockets for server
     grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable);
     grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);

data/src/core/lib/iomgr/pollset_custom.cc

@@ -77,14 +77,14 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   // control back to the application
   grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
   grpc_core::ExecCtx::Set(nullptr);
-  poller_vtable->poll(static_cast<size_t>(timeout));
+  grpc_error* err = poller_vtable->poll(static_cast<size_t>(timeout));
   grpc_core::ExecCtx::Set(curr);
   grpc_core::ExecCtx::Get()->InvalidateNow();
   if (grpc_core::ExecCtx::Get()->HasWork()) {
     grpc_core::ExecCtx::Get()->Flush();
   }
   gpr_mu_lock(&pollset->mu);
-  return GRPC_ERROR_NONE;
+  return err;
 }
 
 static grpc_error_handle pollset_kick(

data/src/core/lib/iomgr/pollset_custom.h

@@ -21,11 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/error.h"
+
 #include <stddef.h>
 
 typedef struct grpc_custom_poller_vtable {
   void (*init)();
-  void (*poll)(size_t timeout_ms);
+  grpc_error* (*poll)(size_t timeout_ms);
   void (*kick)();
   void (*shutdown)();
 } grpc_custom_poller_vtable;

data/src/core/lib/iomgr/pollset_uv.cc

@@ -24,6 +24,7 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/pollset_custom.h"
 
 #include <uv.h>
@@ -54,7 +55,7 @@ static void empty_timer_cb(uv_timer_t* handle) {}
 
 static void kick_timer_cb(uv_timer_t* handle) { g_kicked = false; }
 
-static void run_loop(size_t timeout) {
+static grpc_error* run_loop(size_t timeout) {
   if (grpc_pollset_work_run_loop) {
     if (timeout == 0) {
       uv_run(uv_default_loop(), UV_RUN_NOWAIT);
@@ -64,6 +65,7 @@ static void run_loop(size_t timeout) {
       uv_timer_stop(&g_handle->poll_timer);
     }
   }
+  return GRPC_ERROR_NONE;
 }
 
 static void kick() {

data/src/core/lib/iomgr/pollset_uv.h

@@ -19,11 +19,15 @@
 #ifndef GRPC_CORE_LIB_IOMGR_POLLSET_UV_H
 #define GRPC_CORE_LIB_IOMGR_POLLSET_UV_H
 
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/error.h"
+
 extern int grpc_pollset_work_run_loop;
 
 typedef struct grpc_custom_poller_vtable {
   void (*init)(void);
-  void (*run_loop)(int blocking);
+  grpc_error* (*run_loop)(int blocking);
 } grpc_custom_poller_vtable;
 
 void grpc_custom_pollset_global_init(grpc_custom_poller_vtable* vtable);

data/src/core/lib/iomgr/port.h

@@ -15,12 +15,11 @@
  * limitations under the License.
  *
  */
-
-#include <grpc/support/port_platform.h>
-
 #ifndef GRPC_CORE_LIB_IOMGR_PORT_H
 #define GRPC_CORE_LIB_IOMGR_PORT_H
 
+#include <grpc/support/port_platform.h>
+
 #ifdef GRPC_UV
 #ifndef GRPC_CUSTOM_SOCKET
 #define GRPC_CUSTOM_SOCKET
@@ -33,6 +32,8 @@
 #endif
 #if defined(GRPC_CUSTOM_SOCKET)
 // Do Nothing
+#elif defined(GRPC_USE_EVENT_ENGINE)
+// Do Nothing
 #elif defined(GPR_WINDOWS)
 #define GRPC_WINSOCK_SOCKET 1
 #define GRPC_WINDOWS_SOCKETUTILS 1
@@ -189,10 +190,11 @@
 #endif
 
 #if defined(GRPC_POSIX_SOCKET) + defined(GRPC_WINSOCK_SOCKET) + \
-        defined(GRPC_CUSTOM_SOCKET) + defined(GRPC_CFSTREAM) != \
+        defined(GRPC_CUSTOM_SOCKET) + defined(GRPC_CFSTREAM) +  \
+        defined(GRPC_USE_EVENT_ENGINE) !=                       \
     1
 #error \
-    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CUSTOM_SOCKET, GRPC_CFSTREAM"
+    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CUSTOM_SOCKET, GRPC_CFSTREAM, GRPC_USE_EVENT_ENGINE"
 #endif
 
 #ifdef GRPC_POSIX_SOCKET

data/src/core/lib/iomgr/python_util.h

@@ -43,4 +43,4 @@ inline int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int i) {
   return GRPC_SLICE_LENGTH(buffer->slices[i]);
 }
 
-#endif
+#endif  // GRPC_CORE_LIB_IOMGR_PYTHON_UTIL_H

data/src/core/lib/iomgr/resolve_address.cc

@@ -15,12 +15,16 @@
  * limitations under the License.
  *
  */
-
 #include <grpc/support/port_platform.h>
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include "src/core/lib/iomgr/resolve_address.h"
 
+namespace grpc_core {
+const char* kDefaultSecurePort = "https";
+}  // namespace grpc_core
+
 grpc_address_resolver_vtable* grpc_resolve_address_impl;
 
 void grpc_set_resolver_impl(grpc_address_resolver_vtable* vtable) {

data/src/core/lib/iomgr/resolve_address.h

@@ -49,6 +49,12 @@ struct grpc_resolved_addresses {
   size_t naddrs;
   grpc_resolved_address* addrs;
 };
+
+namespace grpc_core {
+extern const char* kDefaultSecurePort;
+constexpr int kDefaultSecurePortInt = 443;
+}  // namespace grpc_core
+
 typedef struct grpc_address_resolver_vtable {
   void (*resolve_address)(const char* addr, const char* default_port,
                           grpc_pollset_set* interested_parties,

data/src/core/lib/iomgr/resource_quota.cc

@@ -805,6 +805,8 @@ grpc_resource_user* grpc_resource_user_create(
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
     resource_user->links[i].next = resource_user->links[i].prev = nullptr;
   }
+  // TODO(hork): the RU should own a copy of the name. See Craig's comments on
+  // the EventEngine gRFC for justification.
   if (name != nullptr) {
     resource_user->name = name;
   } else {

data/src/core/lib/iomgr/sockaddr.h

@@ -25,6 +25,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/event_engine/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_custom.h"
 #include "src/core/lib/iomgr/sockaddr_posix.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"

data/src/core/lib/iomgr/socket_mutator.cc

@@ -21,6 +21,7 @@
 #include "src/core/lib/iomgr/socket_mutator.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -37,8 +38,20 @@ grpc_socket_mutator* grpc_socket_mutator_ref(grpc_socket_mutator* mutator) {
   return mutator;
 }
 
-bool grpc_socket_mutator_mutate_fd(grpc_socket_mutator* mutator, int fd) {
-  return mutator->vtable->mutate_fd(fd, mutator);
+bool grpc_socket_mutator_mutate_fd(grpc_socket_mutator* mutator, int fd,
+                                   grpc_fd_usage usage) {
+  if (mutator->vtable->mutate_fd_2 != nullptr) {
+    grpc_mutate_socket_info info{fd, usage};
+    return mutator->vtable->mutate_fd_2(&info, mutator);
+  }
+  switch (usage) {
+    case GRPC_FD_SERVER_CONNECTION_USAGE:
+      return true;
+    case GRPC_FD_CLIENT_CONNECTION_USAGE:
+    case GRPC_FD_SERVER_LISTENER_USAGE:
+      return mutator->vtable->mutate_fd(fd, mutator);
+  }
+  GPR_UNREACHABLE_CODE(return false);
 }
 
 int grpc_socket_mutator_compare(grpc_socket_mutator* a,