grpc 1.50.0 → 1.52.0.pre2

data/src/core/lib/transport/tcp_connect_handshaker.cc

@@ -23,12 +23,13 @@
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/memory/memory.h"
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -49,7 +50,6 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/handshaker.h"
 #include "src/core/lib/transport/handshaker_factory.h"
 #include "src/core/lib/transport/handshaker_registry.h"
@@ -100,7 +100,7 @@ TCPConnectHandshaker::TCPConnectHandshaker(grpc_pollset_set* pollset_set)
   GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
 }
 
-void TCPConnectHandshaker::Shutdown(grpc_error_handle why) {
+void TCPConnectHandshaker::Shutdown(grpc_error_handle /*why*/) {
   // TODO(anramach): After migration to EventEngine, cancel the in-progress
   // TCP connection attempt.
   {
@@ -113,12 +113,10 @@ void TCPConnectHandshaker::Shutdown(grpc_error_handle why) {
       // the necessary clean up.
       if (on_handshake_done_ != nullptr) {
         CleanupArgsForFailureLocked();
-        FinishLocked(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown"));
+        FinishLocked(GRPC_ERROR_CREATE("tcp handshaker shutdown"));
       }
     }
   }
-  GRPC_ERROR_UNREF(why);
 }
 
 void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
@@ -134,8 +132,7 @@ void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
       args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
   if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
     MutexLock lock(&mu_);
-    FinishLocked(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Resolved address in invalid format"));
+    FinishLocked(GRPC_ERROR_CREATE("Resolved address in invalid format"));
     return;
   }
   bind_endpoint_to_pollset_ =
@@ -167,15 +164,12 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       static_cast<TCPConnectHandshaker*>(arg));
   {
     MutexLock lock(&self->mu_);
-    if (!GRPC_ERROR_IS_NONE(error) || self->shutdown_) {
-      if (GRPC_ERROR_IS_NONE(error)) {
-        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown");
-      } else {
-        error = GRPC_ERROR_REF(error);
+    if (!error.ok() || self->shutdown_) {
+      if (error.ok()) {
+        error = GRPC_ERROR_CREATE("tcp handshaker shutdown");
       }
       if (self->endpoint_to_destroy_ != nullptr) {
-        grpc_endpoint_shutdown(self->endpoint_to_destroy_,
-                               GRPC_ERROR_REF(error));
+        grpc_endpoint_shutdown(self->endpoint_to_destroy_, error);
       }
       if (!self->shutdown_) {
         self->CleanupArgsForFailureLocked();
@@ -185,7 +179,6 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
         // The on_handshake_done_ is already as part of shutdown when
         // connecting So nothing to be done here other than unrefing the
         // error.
-        GRPC_ERROR_UNREF(error);
       }
       return;
     }
@@ -196,7 +189,7 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       grpc_endpoint_add_to_pollset_set(self->args_->endpoint,
                                        self->interested_parties_);
     }
-    self->FinishLocked(GRPC_ERROR_NONE);
+    self->FinishLocked(absl::OkStatus());
   }
 }
 
@@ -205,7 +198,7 @@ TCPConnectHandshaker::~TCPConnectHandshaker() {
     grpc_endpoint_destroy(endpoint_to_destroy_);
   }
   if (read_buffer_to_destroy_ != nullptr) {
-    grpc_slice_buffer_destroy_internal(read_buffer_to_destroy_);
+    grpc_slice_buffer_destroy(read_buffer_to_destroy_);
     gpr_free(read_buffer_to_destroy_);
   }
   grpc_pollset_set_destroy(interested_parties_);
@@ -237,6 +230,9 @@ class TCPConnectHandshakerFactory : public HandshakerFactory {
     handshake_mgr->Add(
         MakeRefCounted<TCPConnectHandshaker>(interested_parties));
   }
+  HandshakerPriority Priority() override {
+    return HandshakerPriority::kTCPConnectHandshakers;
+  }
   ~TCPConnectHandshakerFactory() override = default;
 };
 
@@ -244,8 +240,7 @@ class TCPConnectHandshakerFactory : public HandshakerFactory {
 
 void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder) {
   builder->handshaker_registry()->RegisterHandshakerFactory(
-      true /* at_start */, HANDSHAKER_CLIENT,
-      absl::make_unique<TCPConnectHandshakerFactory>());
+      HANDSHAKER_CLIENT, std::make_unique<TCPConnectHandshakerFactory>());
 }
 
 }  // namespace grpc_core

data/src/core/lib/transport/tcp_connect_handshaker.h

@@ -36,4 +36,4 @@ void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+#endif  // GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H

data/src/core/lib/transport/timeout_encoding.cc

@@ -1,20 +1,20 @@
-/*
- *
- * 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>
 
@@ -230,14 +230,14 @@ absl::optional<Duration> ParseTimeout(const Slice& text) {
   const uint8_t* p = text.begin();
   const uint8_t* end = text.end();
   int have_digit = 0;
-  /* skip whitespace */
+  // skip whitespace
   for (; p != end && *p == ' '; p++) {
   }
-  /* decode numeric part */
+  // decode numeric part
   for (; p != end && *p >= '0' && *p <= '9'; p++) {
     int32_t digit = static_cast<int32_t>(*p - static_cast<uint8_t>('0'));
     have_digit = 1;
-    /* spec allows max. 8 digits, but we allow values up to 1,000,000,000 */
+    // spec allows max. 8 digits, but we allow values up to 1,000,000,000
     if (x >= (100 * 1000 * 1000)) {
       if (x != (100 * 1000 * 1000) || digit != 0) {
         return Duration::Infinity();
@@ -246,11 +246,11 @@ absl::optional<Duration> ParseTimeout(const Slice& text) {
     x = x * 10 + digit;
   }
   if (!have_digit) return absl::nullopt;
-  /* skip whitespace */
+  // skip whitespace
   for (; p != end && *p == ' '; p++) {
   }
   if (p == end) return absl::nullopt;
-  /* decode unit specifier */
+  // decode unit specifier
   Duration timeout;
   switch (*p) {
     case 'n':

data/src/core/lib/transport/timeout_encoding.h

@@ -1,20 +1,20 @@
-/*
- *
- * 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_TRANSPORT_TIMEOUT_ENCODING_H
 #define GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H
@@ -69,4 +69,4 @@ absl::optional<Duration> ParseTimeout(const Slice& text);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H */
+#endif  // GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H

data/src/core/lib/transport/transport.cc

@@ -1,20 +1,20 @@
-/*
- *
- * 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>
 
@@ -22,32 +22,42 @@
 
 #include <string.h>
 
+#include <memory>
 #include <new>
 
+#include "absl/status/status.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_stream_refcount(false,
                                                          "stream_refcount");
 
 void grpc_stream_destroy(grpc_stream_refcount* refcount) {
-  if (!grpc_iomgr_is_any_background_poller_thread() &&
-      (grpc_core::ExecCtx::Get()->flags() &
+  if ((grpc_core::ExecCtx::Get()->flags() &
        GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP)) {
-    /* Ick.
-       The thread we're running on MAY be owned (indirectly) by a call-stack.
-       If that's the case, destroying the call-stack MAY try to destroy the
-       thread, which is a tangled mess that we just don't want to ever have to
-       cope with.
-       Throw this over to the executor (on a core-owned thread) and process it
-       there. */
-    grpc_core::Executor::Run(&refcount->destroy, GRPC_ERROR_NONE);
+    // Ick.
+    // The thread we're running on MAY be owned (indirectly) by a call-stack.
+    // If that's the case, destroying the call-stack MAY try to destroy the
+    // thread, which is a tangled mess that we just don't want to ever have to
+    // cope with.
+    // Throw this over to the executor (on a core-owned thread) and process it
+    // there.
+    grpc_event_engine::experimental::GetDefaultEventEngine()->Run([refcount] {
+      grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+      grpc_core::ExecCtx exec_ctx;
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,
+                              absl::OkStatus());
+    });
   } else {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,
-                            GRPC_ERROR_NONE);
+                            absl::OkStatus());
   }
 }
 
@@ -87,6 +97,7 @@ void grpc_transport_move_stats(grpc_transport_stream_stats* from,
                                grpc_transport_stream_stats* to) {
   grpc_transport_move_one_way_stats(&from->incoming, &to->incoming);
   grpc_transport_move_one_way_stats(&from->outgoing, &to->outgoing);
+  to->latency = std::exchange(from->latency, gpr_inf_future(GPR_TIMESPAN));
 }
 
 size_t grpc_transport_stream_size(grpc_transport* transport) {
@@ -162,28 +173,51 @@ void grpc_transport_stream_op_batch_queue_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombinerClosureList* closures) {
   if (batch->cancel_stream) {
-    GRPC_ERROR_UNREF(batch->payload->cancel_stream.cancel_error);
   }
   // Construct a list of closures to execute.
   if (batch->recv_initial_metadata) {
     closures->Add(
         batch->payload->recv_initial_metadata.recv_initial_metadata_ready,
-        GRPC_ERROR_REF(error), "failing recv_initial_metadata_ready");
+        error, "failing recv_initial_metadata_ready");
   }
   if (batch->recv_message) {
-    closures->Add(batch->payload->recv_message.recv_message_ready,
-                  GRPC_ERROR_REF(error), "failing recv_message_ready");
+    closures->Add(batch->payload->recv_message.recv_message_ready, error,
+                  "failing recv_message_ready");
   }
   if (batch->recv_trailing_metadata) {
     closures->Add(
         batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
-        GRPC_ERROR_REF(error), "failing recv_trailing_metadata_ready");
+        error, "failing recv_trailing_metadata_ready");
   }
   if (batch->on_complete != nullptr) {
-    closures->Add(batch->on_complete, GRPC_ERROR_REF(error),
-                  "failing on_complete");
+    closures->Add(batch->on_complete, error, "failing on_complete");
+  }
+}
+
+void grpc_transport_stream_op_batch_finish_with_failure_from_transport(
+    grpc_transport_stream_op_batch* batch, grpc_error_handle error) {
+  if (batch->cancel_stream) {
+  }
+  // Construct a list of closures to execute.
+  if (batch->recv_initial_metadata) {
+    grpc_core::ExecCtx::Run(
+        DEBUG_LOCATION,
+        batch->payload->recv_initial_metadata.recv_initial_metadata_ready,
+        error);
+  }
+  if (batch->recv_message) {
+    grpc_core::ExecCtx::Run(
+        DEBUG_LOCATION, batch->payload->recv_message.recv_message_ready, error);
+  }
+  if (batch->recv_trailing_metadata) {
+    grpc_core::ExecCtx::Run(
+        DEBUG_LOCATION,
+        batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
+        error);
+  }
+  if (batch->on_complete != nullptr) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, batch->on_complete, error);
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 struct made_transport_op {
@@ -197,8 +231,7 @@ struct made_transport_op {
 
 static void destroy_made_transport_op(void* arg, grpc_error_handle error) {
   made_transport_op* op = static_cast<made_transport_op*>(arg);
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->inner_on_complete,
-                          GRPC_ERROR_REF(error));
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->inner_on_complete, error);
   delete op;
 }
 
@@ -223,7 +256,7 @@ static void destroy_made_transport_stream_op(void* arg,
   grpc_closure* c = op->inner_on_complete;
   delete op;
   if (c != nullptr) {
-    grpc_core::Closure::Run(DEBUG_LOCATION, c, GRPC_ERROR_REF(error));
+    grpc_core::Closure::Run(DEBUG_LOCATION, c, error);
   }
 }
 
@@ -237,3 +270,17 @@ grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
   op->op.on_complete = &op->outer_on_complete;
   return &op->op;
 }
+
+namespace grpc_core {
+
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status) {
+  auto hdl =
+      GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+  hdl->Set(GrpcStatusMetadata(), static_cast<grpc_status_code>(status.code()));
+  if (!status.ok()) {
+    hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(status.message()));
+  }
+  return hdl;
+}
+
+}  // namespace grpc_core