grpc 1.64.0 → 1.65.2

data/src/core/lib/slice/slice_refcount.cc

@@ -1,20 +0,0 @@
-// Copyright 2016 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 "src/core/lib/slice/slice_refcount.h"
-
-#include <grpc/support/port_platform.h>
-
-grpc_core::DebugOnlyTraceFlag grpc_slice_refcount_trace(false,
-                                                        "slice_refcount");

data/src/core/lib/surface/api_trace.cc

@@ -1,25 +0,0 @@
-//
-//
-// 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 "src/core/lib/surface/api_trace.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/debug/trace.h"
-
-grpc_core::TraceFlag grpc_api_trace(false, "api");

data/src/core/lib/surface/call_trace.h

@@ -1,24 +0,0 @@
-// 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_SRC_CORE_LIB_SURFACE_CALL_TRACE_H
-#define GRPC_SRC_CORE_LIB_SURFACE_CALL_TRACE_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/debug/trace.h"
-
-extern grpc_core::TraceFlag grpc_call_trace;
-
-#endif  // GRPC_SRC_CORE_LIB_SURFACE_CALL_TRACE_H

data/src/core/lib/surface/wait_for_cq_end_op.cc

@@ -1,75 +0,0 @@
-// Copyright 2024 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 "src/core/lib/surface/wait_for_cq_end_op.h"
-
-#include <atomic>
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/match.h"
-#include "src/core/lib/promise/trace.h"
-
-namespace grpc_core {
-Poll<Empty> WaitForCqEndOp::operator()() {
-  if (grpc_trace_promise_primitives.enabled()) {
-    gpr_log(GPR_INFO, "%sWaitForCqEndOp[%p] %s",
-            Activity::current()->DebugTag().c_str(), this,
-            StateString(state_).c_str());
-  }
-  if (auto* n = absl::get_if<NotStarted>(&state_)) {
-    if (n->is_closure) {
-      ExecCtx::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(n->tag),
-                   std::move(n->error));
-      return Empty{};
-    } else {
-      auto not_started = std::move(*n);
-      auto& started =
-          state_.emplace<Started>(GetContext<Activity>()->MakeOwningWaker());
-      grpc_cq_end_op(
-          not_started.cq, not_started.tag, std::move(not_started.error),
-          [](void* p, grpc_cq_completion*) {
-            auto started = static_cast<Started*>(p);
-            auto wakeup = std::move(started->waker);
-            started->done.store(true, std::memory_order_release);
-            wakeup.Wakeup();
-          },
-          &started, &started.completion);
-    }
-  }
-  auto& started = absl::get<Started>(state_);
-  if (started.done.load(std::memory_order_acquire)) {
-    return Empty{};
-  } else {
-    return Pending{};
-  }
-}
-
-std::string WaitForCqEndOp::StateString(const State& state) {
-  return Match(
-      state,
-      [](const NotStarted& x) {
-        return absl::StrFormat(
-            "NotStarted{is_closure=%s, tag=%p, error=%s, cq=%p}",
-            x.is_closure ? "true" : "false", x.tag, x.error.ToString(), x.cq);
-      },
-      [](const Started& x) {
-        return absl::StrFormat(
-            "Started{completion=%p, done=%s}", &x.completion,
-            x.done.load(std::memory_order_relaxed) ? "true" : "false");
-      },
-      [](const Invalid&) -> std::string { return "Invalid{}"; });
-}
-
-}  // namespace grpc_core

data/src/core/lib/surface/wait_for_cq_end_op.h

@@ -1,72 +0,0 @@
-// Copyright 2023 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_SRC_CORE_LIB_SURFACE_WAIT_FOR_CQ_END_OP_H
-#define GRPC_SRC_CORE_LIB_SURFACE_WAIT_FOR_CQ_END_OP_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/promise/activity.h"
-#include "src/core/lib/surface/completion_queue.h"
-
-namespace grpc_core {
-
-// Defines a promise that calls grpc_cq_end_op() (on first poll) and then waits
-// for the callback supplied to grpc_cq_end_op() to be called, before resolving
-// to Empty{}
-class WaitForCqEndOp {
- public:
-  WaitForCqEndOp(bool is_closure, void* tag, grpc_error_handle error,
-                 grpc_completion_queue* cq)
-      : state_{NotStarted{is_closure, tag, std::move(error), cq}} {}
-
-  Poll<Empty> operator()();
-
-  WaitForCqEndOp(const WaitForCqEndOp&) = delete;
-  WaitForCqEndOp& operator=(const WaitForCqEndOp&) = delete;
-  WaitForCqEndOp(WaitForCqEndOp&& other) noexcept
-      : state_(std::move(absl::get<NotStarted>(other.state_))) {
-    other.state_.emplace<Invalid>();
-  }
-  WaitForCqEndOp& operator=(WaitForCqEndOp&& other) noexcept {
-    state_ = std::move(absl::get<NotStarted>(other.state_));
-    other.state_.emplace<Invalid>();
-    return *this;
-  }
-
- private:
-  struct NotStarted {
-    bool is_closure;
-    void* tag;
-    grpc_error_handle error;
-    grpc_completion_queue* cq;
-  };
-  struct Started {
-    explicit Started(Waker waker) : waker(std::move(waker)) {}
-    Waker waker;
-    grpc_cq_completion completion;
-    std::atomic<bool> done{false};
-  };
-  struct Invalid {};
-  using State = absl::variant<NotStarted, Started, Invalid>;
-
-  static std::string StateString(const State& state);
-
-  State state_{Invalid{}};
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_LIB_SURFACE_WAIT_FOR_CQ_END_OP_H

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

@@ -1,172 +0,0 @@
-// Copyright 2023 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 "src/core/lib/transport/batch_builder.h"
-
-#include <type_traits>
-
-#include "absl/log/check.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/promise/poll.h"
-#include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/call_trace.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/transport.h"
-
-namespace grpc_core {
-
-BatchBuilder::BatchBuilder(grpc_transport_stream_op_batch_payload* payload)
-    : payload_(payload) {}
-
-void BatchBuilder::PendingCompletion::CompletionCallback(
-    void* self, grpc_error_handle error) {
-  auto* pc = static_cast<PendingCompletion*>(self);
-  auto* party = pc->batch->party.get();
-  if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%sFinish batch-component %s: status=%s",
-            pc->batch->DebugPrefix(party).c_str(),
-            std::string(pc->name()).c_str(), error.ToString().c_str());
-  }
-  party->Spawn(
-      "batch-completion",
-      [pc, error = std::move(error)]() mutable {
-        RefCountedPtr<Batch> batch = std::exchange(pc->batch, nullptr);
-        pc->done_latch.Set(std::move(error));
-        return Empty{};
-      },
-      [](Empty) {});
-}
-
-BatchBuilder::PendingCompletion::PendingCompletion(RefCountedPtr<Batch> batch)
-    : batch(std::move(batch)) {
-  GRPC_CLOSURE_INIT(&on_done_closure, CompletionCallback, this, nullptr);
-}
-
-BatchBuilder::Batch::Batch(grpc_transport_stream_op_batch_payload* payload,
-                           grpc_stream_refcount* stream_refcount)
-    : party(GetContext<Party>()->Ref()), stream_refcount(stream_refcount) {
-  batch.payload = payload;
-  batch.is_traced = GetContext<CallContext>()->traced();
-#ifndef NDEBUG
-  grpc_stream_ref(stream_refcount, "pending-batch");
-#else
-  grpc_stream_ref(stream_refcount);
-#endif
-}
-
-BatchBuilder::Batch::~Batch() {
-  if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] [batch %p] Destroy",
-            GetContext<Activity>()->DebugTag().c_str(), this);
-  }
-  delete pending_receive_message;
-  delete pending_receive_initial_metadata;
-  delete pending_receive_trailing_metadata;
-  delete pending_sends;
-  if (batch.cancel_stream) {
-    delete batch.payload;
-  }
-#ifndef NDEBUG
-  grpc_stream_unref(stream_refcount, "pending-batch");
-#else
-  grpc_stream_unref(stream_refcount);
-#endif
-}
-
-BatchBuilder::Batch* BatchBuilder::GetBatch(Target target) {
-  if (target_.has_value() &&
-      (target_->stream != target.stream ||
-       target.transport->filter_stack_transport()
-           ->HackyDisableStreamOpBatchCoalescingInConnectedChannel())) {
-    FlushBatch();
-  }
-  if (!target_.has_value()) {
-    target_ = target;
-    batch_ = GetContext<Arena>()->NewPooled<Batch>(payload_,
-                                                   target_->stream_refcount);
-  }
-  CHECK_NE(batch_, nullptr);
-  return batch_;
-}
-
-void BatchBuilder::FlushBatch() {
-  CHECK_NE(batch_, nullptr);
-  CHECK(target_.has_value());
-  if (grpc_call_trace.enabled()) {
-    gpr_log(
-        GPR_DEBUG, "%sPerform transport stream op batch: %p %s",
-        batch_->DebugPrefix().c_str(), &batch_->batch,
-        grpc_transport_stream_op_batch_string(&batch_->batch, false).c_str());
-  }
-  std::exchange(batch_, nullptr)->PerformWith(*target_);
-  target_.reset();
-}
-
-void BatchBuilder::Batch::PerformWith(Target target) {
-  target.transport->filter_stack_transport()->PerformStreamOp(target.stream,
-                                                              &batch);
-}
-
-ServerMetadataHandle BatchBuilder::CompleteSendServerTrailingMetadata(
-    Batch* batch, ServerMetadataHandle sent_metadata, absl::Status send_result,
-    bool actually_sent) {
-  if (!send_result.ok()) {
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_DEBUG,
-              "%sSend metadata failed with error: %s, fabricating trailing "
-              "metadata",
-              batch->DebugPrefix().c_str(), send_result.ToString().c_str());
-    }
-    sent_metadata->Clear();
-    sent_metadata->Set(GrpcStatusMetadata(),
-                       static_cast<grpc_status_code>(send_result.code()));
-    sent_metadata->Set(GrpcMessageMetadata(),
-                       Slice::FromCopiedString(send_result.message()));
-    sent_metadata->Set(GrpcCallWasCancelled(), true);
-  }
-  if (!sent_metadata->get(GrpcCallWasCancelled()).has_value()) {
-    if (grpc_call_trace.enabled()) {
-      gpr_log(
-          GPR_DEBUG,
-          "%sTagging trailing metadata with cancellation status from "
-          "transport: %s",
-          batch->DebugPrefix().c_str(),
-          actually_sent ? "sent => not-cancelled" : "not-sent => cancelled");
-    }
-    sent_metadata->Set(GrpcCallWasCancelled(), !actually_sent);
-  }
-  return sent_metadata;
-}
-
-BatchBuilder::Batch* BatchBuilder::MakeCancel(
-    grpc_stream_refcount* stream_refcount, absl::Status status) {
-  auto* arena = GetContext<Arena>();
-  auto* payload =
-      arena->NewPooled<grpc_transport_stream_op_batch_payload>(nullptr);
-  auto* batch = arena->NewPooled<Batch>(payload, stream_refcount);
-  batch->batch.cancel_stream = true;
-  payload->cancel_stream.cancel_error = std::move(status);
-  return batch;
-}
-
-void BatchBuilder::Cancel(Target target, absl::Status status) {
-  auto* batch = MakeCancel(target.stream_refcount, std::move(status));
-  batch->batch.on_complete =
-      NewClosure([batch](absl::Status) { delete batch; });
-  batch->PerformWith(target);
-}
-
-}  // namespace grpc_core