grpc 1.55.0 → 1.56.2

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

@@ -16,13 +16,18 @@
 //
 //
 
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include <grpc/support/atm.h>
+
 // FIXME: "posix" files shouldn't be depending on _GNU_SOURCE
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
+#include <grpc/event_engine/event_engine.h>
 #endif
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP_SERVER
@@ -75,6 +80,8 @@
 #include "src/core/lib/transport/error_utils.h"
 
 static std::atomic<int64_t> num_dropped_connections{0};
+static constexpr grpc_core::Duration kRetryAcceptWaitTime{
+    grpc_core::Duration::Seconds(1)};
 
 using ::grpc_event_engine::experimental::EndpointConfig;
 using ::grpc_event_engine::experimental::EventEngine;
@@ -86,99 +93,118 @@ using ::grpc_event_engine::experimental::SliceBuffer;
 static grpc_error_handle CreateEventEngineListener(
     grpc_tcp_server* s, grpc_closure* shutdown_complete,
     const EndpointConfig& config, grpc_tcp_server** server) {
-  PosixEventEngineWithFdSupport::PosixAcceptCallback accept_cb =
-      [s](int listener_fd, std::unique_ptr<EventEngine::Endpoint> ep,
-          bool is_external, MemoryAllocator /*allocator*/,
-          SliceBuffer* pending_data) {
-        grpc_core::ApplicationCallbackExecCtx app_ctx;
-        grpc_core::ExecCtx exec_ctx;
-        grpc_tcp_server_acceptor* acceptor =
-            static_cast<grpc_tcp_server_acceptor*>(
-                gpr_malloc(sizeof(*acceptor)));
-        acceptor->from_server = s;
-        acceptor->port_index = -1;
-        acceptor->fd_index = -1;
-        if (!is_external) {
-          auto it = s->listen_fd_to_index_map.find(listener_fd);
-          if (it != s->listen_fd_to_index_map.end()) {
-            acceptor->port_index = std::get<0>(it->second);
-            acceptor->fd_index = std::get<1>(it->second);
-          }
-        } else {
-          // External connection handling.
-          grpc_resolved_address addr;
-          memset(&addr, 0, sizeof(addr));
-          addr.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
-          // Get the fd of the socket connected to peer.
-          int fd =
-              reinterpret_cast<
-                  grpc_event_engine::experimental::PosixEndpointWithFdSupport*>(
-                  ep.get())
-                  ->GetWrappedFd();
-          if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
-                          &(addr.len)) < 0) {
-            gpr_log(GPR_ERROR, "Failed getpeername: %s",
-                    grpc_core::StrError(errno).c_str());
-            close(fd);
-            return;
+  absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener;
+  if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
+    PosixEventEngineWithFdSupport::PosixAcceptCallback accept_cb =
+        [s](int listener_fd, std::unique_ptr<EventEngine::Endpoint> ep,
+            bool is_external, MemoryAllocator /*allocator*/,
+            SliceBuffer* pending_data) {
+          grpc_core::ApplicationCallbackExecCtx app_ctx;
+          grpc_core::ExecCtx exec_ctx;
+          grpc_tcp_server_acceptor* acceptor =
+              static_cast<grpc_tcp_server_acceptor*>(
+                  gpr_malloc(sizeof(*acceptor)));
+          acceptor->from_server = s;
+          acceptor->port_index = -1;
+          acceptor->fd_index = -1;
+          if (!is_external) {
+            auto it = s->listen_fd_to_index_map.find(listener_fd);
+            if (it != s->listen_fd_to_index_map.end()) {
+              acceptor->port_index = std::get<0>(it->second);
+              acceptor->fd_index = std::get<1>(it->second);
+            }
+          } else {
+            // External connection handling.
+            grpc_resolved_address addr;
+            memset(&addr, 0, sizeof(addr));
+            addr.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
+            // Get the fd of the socket connected to peer.
+            int fd = reinterpret_cast<grpc_event_engine::experimental::
+                                          PosixEndpointWithFdSupport*>(ep.get())
+                         ->GetWrappedFd();
+            if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
+                            &(addr.len)) < 0) {
+              gpr_log(GPR_ERROR, "Failed getpeername: %s",
+                      grpc_core::StrError(errno).c_str());
+              close(fd);
+              return;
+            }
+            (void)grpc_set_socket_no_sigpipe_if_possible(fd);
+            auto addr_uri = grpc_sockaddr_to_uri(&addr);
+            if (!addr_uri.ok()) {
+              gpr_log(GPR_ERROR, "Invalid address: %s",
+                      addr_uri.status().ToString().c_str());
+              return;
+            }
+            if (grpc_tcp_trace.enabled()) {
+              gpr_log(GPR_INFO,
+                      "SERVER_CONNECT: incoming external connection: %s",
+                      addr_uri->c_str());
+            }
           }
-          (void)grpc_set_socket_no_sigpipe_if_possible(fd);
-          auto addr_uri = grpc_sockaddr_to_uri(&addr);
-          if (!addr_uri.ok()) {
-            gpr_log(GPR_ERROR, "Invalid address: %s",
-                    addr_uri.status().ToString().c_str());
-            return;
+          grpc_pollset* read_notifier_pollset =
+              (*(s->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
+                                   &s->next_pollset_to_assign, 1)) %
+                               s->pollsets->size()];
+          acceptor->external_connection = is_external;
+          acceptor->listener_fd = listener_fd;
+          grpc_byte_buffer* buf = nullptr;
+          if (pending_data != nullptr && pending_data->Length() > 0) {
+            buf = grpc_raw_byte_buffer_create(nullptr, 0);
+            grpc_slice_buffer_swap(&buf->data.raw.slice_buffer,
+                                   pending_data->c_slice_buffer());
+            pending_data->Clear();
           }
-          if (grpc_tcp_trace.enabled()) {
-            gpr_log(GPR_INFO,
-                    "SERVER_CONNECT: incoming external connection: %s",
-                    addr_uri->c_str());
-          }
-        }
-        grpc_pollset* read_notifier_pollset =
-            (*(s->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
-                                 &s->next_pollset_to_assign, 1)) %
-                             s->pollsets->size()];
-        acceptor->external_connection = is_external;
-        acceptor->listener_fd = listener_fd;
-        grpc_byte_buffer* buf = nullptr;
-        if (pending_data != nullptr && pending_data->Length() > 0) {
-          buf = grpc_raw_byte_buffer_create(nullptr, 0);
-          grpc_slice_buffer_swap(&buf->data.raw.slice_buffer,
-                                 pending_data->c_slice_buffer());
-          pending_data->Clear();
-        }
-        acceptor->pending_data = buf;
-        s->on_accept_cb(
-            s->on_accept_cb_arg,
-            grpc_event_engine::experimental::grpc_event_engine_endpoint_create(
-                std::move(ep)),
-            read_notifier_pollset, acceptor);
-      };
-  auto on_shutdown_complete_cb =
-      grpc_event_engine::experimental::GrpcClosureToStatusCallback(
-          shutdown_complete);
-  PosixEventEngineWithFdSupport* engine_ptr =
-      reinterpret_cast<PosixEventEngineWithFdSupport*>(
-          config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
-  // Keeps the engine alive for some tests that have not otherwise instantiated
-  // an EventEngine
-  std::shared_ptr<EventEngine> keeper;
-  if (engine_ptr == nullptr) {
-    keeper = grpc_event_engine::experimental::GetDefaultEventEngine();
-    engine_ptr = reinterpret_cast<PosixEventEngineWithFdSupport*>(keeper.get());
-  }
-  auto listener = engine_ptr->CreatePosixListener(
-      std::move(accept_cb),
-      [s, shutdown_complete](absl::Status status) {
-        grpc_event_engine::experimental::RunEventEngineClosure(
-            shutdown_complete, absl_status_to_grpc_error(status));
-        delete s->fd_handler;
-        delete s;
-      },
-      config,
-      std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
-          s->memory_quota));
+          acceptor->pending_data = buf;
+          s->on_accept_cb(s->on_accept_cb_arg,
+                          grpc_event_engine::experimental::
+                              grpc_event_engine_endpoint_create(std::move(ep)),
+                          read_notifier_pollset, acceptor);
+        };
+    PosixEventEngineWithFdSupport* engine_ptr =
+        reinterpret_cast<PosixEventEngineWithFdSupport*>(
+            config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+    // Keeps the engine alive for some tests that have not otherwise
+    // instantiated an EventEngine
+    std::shared_ptr<EventEngine> keeper;
+    if (engine_ptr == nullptr) {
+      keeper = grpc_event_engine::experimental::GetDefaultEventEngine();
+      engine_ptr =
+          reinterpret_cast<PosixEventEngineWithFdSupport*>(keeper.get());
+    }
+    listener = engine_ptr->CreatePosixListener(
+        std::move(accept_cb),
+        [s, shutdown_complete](absl::Status status) {
+          grpc_event_engine::experimental::RunEventEngineClosure(
+              shutdown_complete, absl_status_to_grpc_error(status));
+          delete s->fd_handler;
+          delete s;
+        },
+        config,
+        std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
+            s->memory_quota));
+  } else {
+    EventEngine::Listener::AcceptCallback accept_cb =
+        [s](std::unique_ptr<EventEngine::Endpoint> ep, MemoryAllocator) {
+          s->on_accept_cb(s->on_accept_cb_arg,
+                          grpc_event_engine::experimental::
+                              grpc_event_engine_endpoint_create(std::move(ep)),
+                          nullptr, nullptr);
+        };
+    auto ee = grpc_event_engine::experimental::GetDefaultEventEngine();
+    listener = ee->CreateListener(
+        std::move(accept_cb),
+        [s, ee, shutdown_complete](absl::Status status) {
+          GPR_ASSERT(gpr_atm_no_barrier_load(&s->refs.count) == 0);
+          grpc_event_engine::experimental::RunEventEngineClosure(
+              shutdown_complete, absl_status_to_grpc_error(status));
+          delete s->fd_handler;
+          delete s;
+        },
+        config,
+        std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
+            s->memory_quota));
+  }
   if (!listener.ok()) {
     delete s;
     *server = nullptr;
@@ -339,22 +365,38 @@ static void on_read(void* arg, grpc_error_handle err) {
     if (fd < 0) {
       if (errno == EINTR) {
         continue;
-      } else if (errno == EAGAIN || errno == ECONNABORTED ||
-                 errno == EWOULDBLOCK) {
+      }
+      // When the process runs out of fds, accept4() returns EMFILE. When this
+      // happens, the connection is left in the accept queue until either a
+      // read event triggers the on_read callback, or time has passed and the
+      // accept should be re-tried regardless. This callback is not cancelled,
+      // so a spurious wakeup may occur even when there's nothing to accept.
+      // This is not a performant code path, but if an fd limit has been
+      // reached, the system is likely in an unhappy state regardless.
+      if (errno == EMFILE) {
+        GRPC_LOG_EVERY_N_SEC(1, GPR_ERROR, "%s",
+                             "File descriptor limit reached. Retrying.");
         grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
+        if (gpr_atm_full_xchg(&sp->retry_timer_armed, true)) return;
+        grpc_timer_init(&sp->retry_timer,
+                        grpc_core::Timestamp::Now() + kRetryAcceptWaitTime,
+                        &sp->retry_closure);
         return;
+      }
+      if (errno == EAGAIN || errno == ECONNABORTED || errno == EWOULDBLOCK) {
+        grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
+        return;
+      }
+      gpr_mu_lock(&sp->server->mu);
+      if (!sp->server->shutdown_listeners) {
+        gpr_log(GPR_ERROR, "Failed accept4: %s",
+                grpc_core::StrError(errno).c_str());
       } else {
-        gpr_mu_lock(&sp->server->mu);
-        if (!sp->server->shutdown_listeners) {
-          gpr_log(GPR_ERROR, "Failed accept4: %s",
-                  grpc_core::StrError(errno).c_str());
-        } else {
-          // if we have shutdown listeners, accept4 could fail, and we
-          // needn't notify users
-        }
-        gpr_mu_unlock(&sp->server->mu);
-        goto error;
+        // if we have shutdown listeners, accept4 could fail, and we
+        // needn't notify users
       }
+      gpr_mu_unlock(&sp->server->mu);
+      goto error;
     }
 
     if (sp->server->memory_quota->IsMemoryPressureHigh()) {
@@ -547,6 +589,7 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
     sp->port_index = listener->port_index;
     sp->fd_index = listener->fd_index + count - i;
     GPR_ASSERT(sp->emfd);
+    grpc_tcp_server_listener_initialize_retry_timer(sp);
     while (listener->server->tail->next != nullptr) {
       listener->server->tail = listener->server->tail->next;
     }
@@ -565,16 +608,27 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
       return absl::UnknownError("Server already shutdown");
     }
     int fd_index = 0;
-    auto port = s->ee_listener->BindWithFd(
-        grpc_event_engine::experimental::CreateResolvedAddress(*addr),
-        [s, &fd_index](absl::StatusOr<int> listen_fd) {
-          if (!listen_fd.ok()) {
-            return;
-          }
-          GPR_DEBUG_ASSERT(*listen_fd > 0);
-          s->listen_fd_to_index_map.insert_or_assign(
-              *listen_fd, std::make_tuple(s->n_bind_ports, fd_index++));
-        });
+    absl::StatusOr<int> port;
+    if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
+      port =
+          static_cast<
+              grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
+              s->ee_listener.get())
+              ->BindWithFd(
+                  grpc_event_engine::experimental::CreateResolvedAddress(*addr),
+                  [s, &fd_index](absl::StatusOr<int> listen_fd) {
+                    if (!listen_fd.ok()) {
+                      return;
+                    }
+                    GPR_DEBUG_ASSERT(*listen_fd > 0);
+                    s->listen_fd_to_index_map.insert_or_assign(
+                        *listen_fd,
+                        std::make_tuple(s->n_bind_ports, fd_index++));
+                  });
+    } else {
+      port = s->ee_listener->Bind(
+          grpc_event_engine::experimental::CreateResolvedAddress(*addr));
+    }
     if (port.ok()) {
       s->n_bind_ports++;
       *out_port = *port;
@@ -774,12 +828,17 @@ static void tcp_server_shutdown_listeners(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
   s->shutdown_listeners = true;
   if (grpc_event_engine::experimental::UseEventEngineListener()) {
-    s->ee_listener->ShutdownListeningFds();
+    if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
+      static_cast<grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
+          s->ee_listener.get())
+          ->ShutdownListeningFds();
+    }
   }
   /* shutdown all fd's */
   if (s->active_ports) {
     grpc_tcp_listener* sp;
     for (sp = s->head; sp; sp = sp->next) {
+      grpc_timer_cancel(&sp->retry_timer);
       grpc_fd_shutdown(sp->emfd, GRPC_ERROR_CREATE("Server shutdown"));
     }
   }
@@ -804,15 +863,19 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
   // TODO(yangg) resolve duplicate code with on_read
   void Handle(int listener_fd, int fd, grpc_byte_buffer* buf) override {
     if (grpc_event_engine::experimental::UseEventEngineListener()) {
+      GPR_ASSERT(grpc_event_engine::experimental::EventEngineSupportsFd());
       grpc_event_engine::experimental::SliceBuffer pending_data;
       if (buf != nullptr) {
         pending_data =
             grpc_event_engine::experimental::SliceBuffer::TakeCSliceBuffer(
                 buf->data.raw.slice_buffer);
       }
-      GPR_ASSERT(GRPC_LOG_IF_ERROR("listener_handle_external_connection",
-                                   s_->ee_listener->HandleExternalConnection(
-                                       listener_fd, fd, &pending_data)));
+      GPR_ASSERT(GRPC_LOG_IF_ERROR(
+          "listener_handle_external_connection",
+          static_cast<
+              grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
+              s_->ee_listener.get())
+              ->HandleExternalConnection(listener_fd, fd, &pending_data)));
       return;
     }
     grpc_pollset* read_notifier_pollset;

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

@@ -30,6 +30,7 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 // one listening port
@@ -52,6 +53,11 @@ typedef struct grpc_tcp_listener {
   // identified while iterating through 'next'.
   struct grpc_tcp_listener* sibling;
   int is_sibling;
+  // If an accept4() call fails, a timer is started to drain the accept queue in
+  // case no further connection attempts reach the gRPC server.
+  grpc_closure retry_closure;
+  grpc_timer retry_timer;
+  gpr_atm retry_timer_armed;
 } grpc_tcp_listener;
 
 // the overall server
@@ -107,7 +113,7 @@ struct grpc_tcp_server {
   /* used when event engine based servers are enabled */
   int n_bind_ports = 0;
   absl::flat_hash_map<int, std::tuple<int, int>> listen_fd_to_index_map;
-  std::unique_ptr<grpc_event_engine::experimental::PosixListenerWithFdSupport>
+  std::unique_ptr<grpc_event_engine::experimental::EventEngine::Listener>
       ee_listener = nullptr;
   /* used to store a pre-allocated FD assigned to a socket */
   int pre_allocated_fd;
@@ -139,4 +145,10 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 // Ruturn true if the platform supports ifaddrs
 bool grpc_tcp_server_have_ifaddrs(void);
 
+// Initialize (but don't start) the timer and callback to retry accept4() on a
+// listening socket after file descriptors have been exhausted. This must be
+// called when creating a new listener.
+void grpc_tcp_server_listener_initialize_retry_timer(
+    grpc_tcp_listener* listener);
+
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/atm.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON
@@ -81,6 +83,24 @@ static int get_max_accept_queue_size(void) {
   return s_max_accept_queue_size;
 }
 
+static void listener_retry_timer_cb(void* arg, grpc_error_handle err) {
+  // Do nothing if cancelled.
+  if (!err.ok()) return;
+  grpc_tcp_listener* listener = static_cast<grpc_tcp_listener*>(arg);
+  gpr_atm_no_barrier_store(&listener->retry_timer_armed, false);
+  if (!grpc_fd_is_shutdown(listener->emfd)) {
+    grpc_fd_set_readable(listener->emfd);
+  }
+}
+
+void grpc_tcp_server_listener_initialize_retry_timer(
+    grpc_tcp_listener* listener) {
+  gpr_atm_no_barrier_store(&listener->retry_timer_armed, false);
+  grpc_timer_init_unset(&listener->retry_timer);
+  GRPC_CLOSURE_INIT(&listener->retry_closure, listener_retry_timer_cb, listener,
+                    grpc_schedule_on_exec_ctx);
+}
+
 static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
                                               const grpc_resolved_address* addr,
                                               unsigned port_index,
@@ -112,6 +132,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
   sp->server = s;
   sp->fd = fd;
   sp->emfd = grpc_fd_create(fd, name.c_str(), true);
+  grpc_tcp_server_listener_initialize_retry_timer(sp);
 
   // Check and set fd as prellocated
   if (grpc_tcp_server_pre_allocated_fd(s) == fd) {

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

@@ -634,7 +634,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
       engine_ptr->poller(), std::move(accept_cb), std::move(on_shutdown),
       std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
           resource_quota->memory_quota()),
-      engine_ptr->shared_from_this(), engine_ptr->executor(), config);
+      engine_ptr->shared_from_this(), engine_ptr->thread_pool(), config);
   s->active_ports = -1;
   s->on_accept_cb = [](void* /* arg */, grpc_endpoint* /* ep */,
                        grpc_pollset* /* accepting_pollset */,

data/src/core/lib/json/json.h

@@ -19,175 +19,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/types/variant.h"
+#include <grpc/support/json.h>
 
 namespace grpc_core {
 
-// A JSON value, which can be any one of object, array, string,
-// number, true, false, or null.
-class Json {
- public:
-  // TODO(roth): Currently, numbers are stored internally as strings,
-  // which makes the API a bit cumbersome to use. When we have time,
-  // consider whether there's a better alternative (e.g., maybe storing
-  // each numeric type as the native C++ type and automatically converting
-  // to string as needed).
-  enum class Type { kNull, kTrue, kFalse, kNumber, kString, kObject, kArray };
-
-  using Object = std::map<std::string, Json>;
-  using Array = std::vector<Json>;
-
-  Json() = default;
-
-  // Copyable.
-  Json(const Json& other) = default;
-  Json& operator=(const Json& other) = default;
-
-  // Moveable.
-  Json(Json&& other) noexcept : value_(std::move(other.value_)) {
-    other.value_ = absl::monostate();
-  }
-  Json& operator=(Json&& other) noexcept {
-    value_ = std::move(other.value_);
-    other.value_ = absl::monostate();
-    return *this;
-  }
-
-  // Construct from copying a string.
-  // If is_number is true, the type will be kNumber instead of kString.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const std::string& string, bool is_number = false)
-      : value_(is_number ? Value(NumberValue{string}) : Value(string)) {}
-  Json& operator=(const std::string& string) {
-    value_ = string;
-    return *this;
-  }
-
-  // Same thing for C-style strings, both const and mutable.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const char* string, bool is_number = false)
-      : Json(std::string(string), is_number) {}
-  Json& operator=(const char* string) {
-    *this = std::string(string);
-    return *this;
-  }
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(char* string, bool is_number = false)
-      : Json(std::string(string), is_number) {}
-  Json& operator=(char* string) {
-    *this = std::string(string);
-    return *this;
-  }
-
-  // Construct by moving a string.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(std::string&& string) : value_(Value(std::move(string))) {}
-  Json& operator=(std::string&& string) {
-    value_ = Value(std::move(string));
-    return *this;
-  }
-
-  // Construct from bool.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(bool b) : value_(b) {}
-  Json& operator=(bool b) {
-    value_ = b;
-    return *this;
-  }
-
-  // Construct from any numeric type.
-  template <typename NumericType>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(NumericType number) : value_(NumberValue{std::to_string(number)}) {}
-  template <typename NumericType>
-  Json& operator=(NumericType number) {
-    value_ = NumberValue{std::to_string(number)};
-    return *this;
-  }
-
-  // Construct by copying object.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const Object& object) : value_(object) {}
-  Json& operator=(const Object& object) {
-    value_ = object;
-    return *this;
-  }
-
-  // Construct by moving object.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(Object&& object) : value_(std::move(object)) {}
-  Json& operator=(Object&& object) {
-    value_ = std::move(object);
-    return *this;
-  }
-
-  // Construct by copying array.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const Array& array) : value_(array) {}
-  Json& operator=(const Array& array) {
-    value_ = array;
-    return *this;
-  }
-
-  // Construct by moving array.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(Array&& array) : value_(std::move(array)) {}
-  Json& operator=(Array&& array) {
-    value_ = std::move(array);
-    return *this;
-  }
-
-  // Returns the JSON type.
-  Type type() const {
-    struct ValueFunctor {
-      Json::Type operator()(const absl::monostate&) { return Type::kNull; }
-      Json::Type operator()(bool value) {
-        return value ? Type::kTrue : Type::kFalse;
-      }
-      Json::Type operator()(const NumberValue&) { return Type::kNumber; }
-      Json::Type operator()(const std::string&) { return Type::kString; }
-      Json::Type operator()(const Object&) { return Type::kObject; }
-      Json::Type operator()(const Array&) { return Type::kArray; }
-    };
-    return absl::visit(ValueFunctor(), value_);
-  }
-
-  // Accessor methods.
-  const std::string& string() const {
-    const NumberValue* num = absl::get_if<NumberValue>(&value_);
-    if (num != nullptr) return num->value;
-    return absl::get<std::string>(value_);
-  }
-  const Object& object() const { return absl::get<Object>(value_); }
-  const Array& array() const { return absl::get<Array>(value_); }
-
-  bool operator==(const Json& other) const { return value_ == other.value_; }
-  bool operator!=(const Json& other) const { return !(*this == other); }
-
- private:
-  struct NumberValue {
-    std::string value;
-
-    bool operator==(const NumberValue& other) const {
-      return value == other.value;
-    }
-  };
-  using Value = absl::variant<absl::monostate,  // kNull
-                              bool,             // kTrue or kFalse
-                              NumberValue,      // kNumber
-                              std::string,      // kString
-                              Object,           // kObject
-                              Array>;           // kArray
-
-  explicit Json(Value value) : value_(std::move(value)) {}
-
-  Value value_;
-};
+using Json = experimental::Json;
 
 }  // namespace grpc_core