grpc 1.55.0 → 1.56.0

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

@@ -0,0 +1,211 @@
+// Copyright 2023 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 GPR_APPLE
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <grpc/support/cpu.h>
+
+#include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+#include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/event_engine/utils.h"
+#include "src/core/lib/gprpp/crash.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+struct CFEventEngine::Closure final : public EventEngine::Closure {
+  absl::AnyInvocable<void()> cb;
+  Timer timer;
+  CFEventEngine* engine;
+  EventEngine::TaskHandle handle;
+
+  void Run() override {
+    GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p executing callback:%s", engine,
+                            HandleToString(handle).c_str());
+    {
+      grpc_core::MutexLock lock(&engine->task_mu_);
+      engine->known_handles_.erase(handle);
+    }
+    cb();
+    delete this;
+  }
+};
+
+CFEventEngine::CFEventEngine()
+    : thread_pool_(
+          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
+      timer_manager_(thread_pool_) {}
+
+CFEventEngine::~CFEventEngine() {
+  {
+    grpc_core::MutexLock lock(&task_mu_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      for (auto handle : known_handles_) {
+        gpr_log(GPR_ERROR,
+                "CFEventEngine:%p uncleared TaskHandle at shutdown:%s", this,
+                HandleToString(handle).c_str());
+      }
+    }
+    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    timer_manager_.Shutdown();
+  }
+  thread_pool_->Quiesce();
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+CFEventEngine::CreateListener(
+    Listener::AcceptCallback /* on_accept */,
+    absl::AnyInvocable<void(absl::Status)> /* on_shutdown */,
+    const EndpointConfig& /* config */,
+    std::unique_ptr<MemoryAllocatorFactory> /* memory_allocator_factory */) {
+  grpc_core::Crash("unimplemented");
+}
+
+CFEventEngine::ConnectionHandle CFEventEngine::Connect(
+    OnConnectCallback on_connect, const ResolvedAddress& addr,
+    const EndpointConfig& /* args */, MemoryAllocator memory_allocator,
+    Duration timeout) {
+  auto endpoint_ptr = new CFStreamEndpoint(
+      std::static_pointer_cast<CFEventEngine>(shared_from_this()),
+      std::move(memory_allocator));
+
+  ConnectionHandle handle{reinterpret_cast<intptr_t>(endpoint_ptr), 0};
+  {
+    grpc_core::MutexLock lock(&conn_mu_);
+    conn_handles_.insert(handle);
+  }
+
+  auto deadline_timer =
+      RunAfter(timeout, [handle, that = std::static_pointer_cast<CFEventEngine>(
+                                     shared_from_this())]() {
+        that->CancelConnectInternal(
+            handle, absl::DeadlineExceededError("Connect timed out"));
+      });
+
+  auto on_connect2 =
+      [that = std::static_pointer_cast<CFEventEngine>(shared_from_this()),
+       deadline_timer, handle,
+       on_connect = std::move(on_connect)](absl::Status status) mutable {
+        // best effort canceling deadline timer
+        that->Cancel(deadline_timer);
+
+        {
+          grpc_core::MutexLock lock(&that->conn_mu_);
+          that->conn_handles_.erase(handle);
+        }
+
+        auto endpoint_ptr = reinterpret_cast<CFStreamEndpoint*>(handle.keys[0]);
+
+        if (!status.ok()) {
+          on_connect(std::move(status));
+          delete endpoint_ptr;
+          return;
+        }
+
+        on_connect(std::unique_ptr<EventEngine::Endpoint>(endpoint_ptr));
+      };
+
+  endpoint_ptr->Connect(std::move(on_connect2), addr);
+
+  return handle;
+}
+
+bool CFEventEngine::CancelConnect(ConnectionHandle handle) {
+  CancelConnectInternal(handle, absl::CancelledError("CancelConnect"));
+  // on_connect will always be called, even if cancellation is successful
+  return false;
+}
+
+bool CFEventEngine::CancelConnectInternal(ConnectionHandle handle,
+                                          absl::Status status) {
+  grpc_core::MutexLock lock(&conn_mu_);
+
+  if (!conn_handles_.contains(handle)) {
+    GRPC_EVENT_ENGINE_TRACE(
+        "Unknown connection handle: %s",
+        HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
+    return false;
+  }
+  conn_handles_.erase(handle);
+
+  // keep the `conn_mu_` lock to prevent endpoint_ptr from being deleted
+
+  auto endpoint_ptr = reinterpret_cast<CFStreamEndpoint*>(handle.keys[0]);
+  return endpoint_ptr->CancelConnect(status);
+}
+
+bool CFEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
+
+std::unique_ptr<EventEngine::DNSResolver> CFEventEngine::GetDNSResolver(
+    const DNSResolver::ResolverOptions& /* options */) {
+  grpc_core::Crash("unimplemented");
+}
+
+void CFEventEngine::Run(EventEngine::Closure* closure) {
+  thread_pool_->Run(closure);
+}
+
+void CFEventEngine::Run(absl::AnyInvocable<void()> closure) {
+  thread_pool_->Run(std::move(closure));
+}
+
+EventEngine::TaskHandle CFEventEngine::RunAfter(Duration when,
+                                                EventEngine::Closure* closure) {
+  return RunAfterInternal(when, [closure]() { closure->Run(); });
+}
+
+EventEngine::TaskHandle CFEventEngine::RunAfter(
+    Duration when, absl::AnyInvocable<void()> closure) {
+  return RunAfterInternal(when, std::move(closure));
+}
+
+bool CFEventEngine::Cancel(TaskHandle handle) {
+  grpc_core::MutexLock lock(&task_mu_);
+  if (!known_handles_.contains(handle)) return false;
+  auto* cd = reinterpret_cast<Closure*>(handle.keys[0]);
+  bool r = timer_manager_.TimerCancel(&cd->timer);
+  known_handles_.erase(handle);
+  if (r) delete cd;
+  return r;
+}
+
+EventEngine::TaskHandle CFEventEngine::RunAfterInternal(
+    Duration when, absl::AnyInvocable<void()> cb) {
+  auto when_ts = ToTimestamp(timer_manager_.Now(), when);
+  auto* cd = new Closure;
+  cd->cb = std::move(cb);
+  cd->engine = this;
+  EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
+                                 aba_token_.fetch_add(1)};
+  grpc_core::MutexLock lock(&task_mu_);
+  known_handles_.insert(handle);
+  cd->handle = handle;
+  GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p scheduling callback:%s", this,
+                          HandleToString(handle).c_str());
+  timer_manager_.TimerInit(&cd->timer, when_ts, cd);
+  return handle;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE

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

@@ -0,0 +1,86 @@
+// Copyright 2023 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_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CF_ENGINE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CF_ENGINE_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/event_engine/posix_engine/event_poller.h"
+#include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
+#include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/surface/init_internally.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class CFEventEngine : public EventEngine,
+                      public Scheduler,
+                      public grpc_core::KeepsGrpcInitialized {
+ public:
+  CFEventEngine();
+  ~CFEventEngine() override;
+
+  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      override;
+
+  ConnectionHandle Connect(OnConnectCallback on_connect,
+                           const ResolvedAddress& addr,
+                           const EndpointConfig& args,
+                           MemoryAllocator memory_allocator,
+                           Duration timeout) override;
+  bool CancelConnect(ConnectionHandle handle) override;
+  bool IsWorkerThread() override;
+  std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) override;
+  void Run(Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+  TaskHandle RunAfter(Duration when, Closure* closure) override;
+  TaskHandle RunAfter(Duration when,
+                      absl::AnyInvocable<void()> closure) override;
+  bool Cancel(TaskHandle handle) override;
+
+ private:
+  struct Closure;
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           absl::AnyInvocable<void()> cb);
+
+  bool CancelConnectInternal(ConnectionHandle handle, absl::Status status);
+
+  grpc_core::Mutex task_mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(task_mu_);
+  std::atomic<intptr_t> aba_token_{0};
+
+  grpc_core::Mutex conn_mu_;
+  ConnectionHandleSet conn_handles_ ABSL_GUARDED_BY(conn_mu_);
+
+  std::shared_ptr<ThreadPool> thread_pool_;
+  TimerManager timer_manager_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CF_ENGINE_H

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.cc

@@ -0,0 +1,354 @@
+// Copyright 2023 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 GPR_APPLE
+
+#include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/gprpp/strerror.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+
+int kDefaultReadBufferSize = 8192;
+
+absl::Status CFErrorToStatus(CFTypeUniqueRef<CFErrorRef> cf_error) {
+  if (cf_error == nullptr) {
+    return absl::OkStatus();
+  }
+  CFErrorDomain cf_domain = CFErrorGetDomain((cf_error));
+  CFIndex code = CFErrorGetCode((cf_error));
+  CFTypeUniqueRef<CFStringRef> cf_desc = CFErrorCopyDescription((cf_error));
+  char domain_buf[256];
+  char desc_buf[256];
+  CFStringGetCString(cf_domain, domain_buf, 256, kCFStringEncodingUTF8);
+  CFStringGetCString(cf_desc, desc_buf, 256, kCFStringEncodingUTF8);
+  return absl::Status(absl::StatusCode::kUnknown,
+                      absl::StrFormat("(domain:%s, code:%ld, description:%s)",
+                                      domain_buf, code, desc_buf));
+}
+
+absl::StatusOr<EventEngine::ResolvedAddress> CFReadStreamLocallAddress(
+    CFReadStreamRef stream) {
+  CFTypeUniqueRef<CFDataRef> cf_native_handle = static_cast<CFDataRef>(
+      CFReadStreamCopyProperty(stream, kCFStreamPropertySocketNativeHandle));
+  CFSocketNativeHandle socket;
+  CFDataGetBytes(cf_native_handle, CFRangeMake(0, sizeof(CFSocketNativeHandle)),
+                 (UInt8*)&socket);
+  EventEngine::ResolvedAddress addr;
+  socklen_t len = EventEngine::ResolvedAddress::MAX_SIZE_BYTES;
+  if (getsockname(socket, const_cast<sockaddr*>(addr.address()), &len) < 0) {
+    return absl::InternalError(
+        absl::StrCat("getsockname:", grpc_core::StrError(errno)));
+  }
+  return EventEngine::ResolvedAddress(addr.address(), len);
+}
+
+}  // namespace
+
+bool CFStreamEndpointImpl::CancelConnect(absl::Status status) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
+      "CFStreamEndpointImpl::CancelConnect: status: %s, this: %p",
+      status.ToString().c_str(), this);
+
+  return open_event_.SetShutdown(std::move(status));
+}
+
+void CFStreamEndpointImpl::Connect(
+    absl::AnyInvocable<void(absl::Status)> on_connect,
+    EventEngine::ResolvedAddress addr) {
+  auto addr_uri = ResolvedAddressToURI(addr);
+
+  if (!addr_uri.ok()) {
+    on_connect(std::move(addr_uri).status());
+    return;
+  }
+
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Connect: %s",
+                                   addr_uri.value().c_str());
+
+  peer_address_ = std::move(addr);
+  auto host_port = ResolvedAddressToNormalizedString(peer_address_);
+  if (!host_port.ok()) {
+    on_connect(std::move(host_port).status());
+    return;
+  }
+
+  peer_address_string_ = host_port.value();
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
+      "CFStreamEndpointImpl::Connect, host_port: %s", host_port->c_str());
+
+  std::string host_string;
+  std::string port_string;
+  grpc_core::SplitHostPort(host_port.value(), &host_string, &port_string);
+  CFStringRef host = CFStringCreateWithCString(NULL, host_string.c_str(),
+                                               kCFStringEncodingUTF8);
+  int port = ResolvedAddressGetPort(peer_address_);
+  CFStreamCreatePairWithSocketToHost(NULL, host, port, &cf_read_stream_,
+                                     &cf_write_stream_);
+
+  CFStreamClientContext cf_context = {0, this, Retain, Release, nullptr};
+  CFReadStreamSetClient(
+      cf_read_stream_,
+      kCFStreamEventOpenCompleted | kCFStreamEventHasBytesAvailable |
+          kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,
+      ReadCallback, &cf_context);
+  CFWriteStreamSetClient(
+      cf_write_stream_,
+      kCFStreamEventOpenCompleted | kCFStreamEventCanAcceptBytes |
+          kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,
+      WriteCallback, &cf_context);
+  CFReadStreamSetDispatchQueue(cf_read_stream_,
+                               dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0));
+  CFWriteStreamSetDispatchQueue(
+      cf_write_stream_, dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0));
+
+  if (!CFReadStreamOpen(cf_read_stream_)) {
+    auto status = CFErrorToStatus(CFReadStreamCopyError(cf_read_stream_));
+    on_connect(std::move(status));
+    return;
+  }
+
+  if (!CFWriteStreamOpen(cf_write_stream_)) {
+    auto status = CFErrorToStatus(CFWriteStreamCopyError(cf_write_stream_));
+    on_connect(std::move(status));
+    return;
+  }
+
+  open_event_.NotifyOn(new PosixEngineClosure(
+      [that = Ref(),
+       on_connect = std::move(on_connect)](absl::Status status) mutable {
+        if (!status.ok()) {
+          on_connect(std::move(status));
+          return;
+        }
+
+        auto local_addr = CFReadStreamLocallAddress(that->cf_read_stream_);
+        if (!local_addr.ok()) {
+          on_connect(std::move(local_addr).status());
+          return;
+        }
+
+        that->local_address_ = local_addr.value();
+        that->local_address_string_ =
+            *ResolvedAddressToURI(that->local_address_);
+        on_connect(absl::OkStatus());
+      },
+      false /* is_permanent */));
+}
+
+/* static */ void CFStreamEndpointImpl::ReadCallback(
+    CFReadStreamRef stream, CFStreamEventType type,
+    void* client_callback_info) {
+  auto self = static_cast<CFStreamEndpointImpl*>(client_callback_info);
+
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
+      "CFStreamEndpointImpl::ReadCallback, type: %lu, this: %p", type, self);
+
+  switch (type) {
+    case kCFStreamEventOpenCompleted:
+      // wait for write stream open completed to signal connection ready
+      break;
+    case kCFStreamEventHasBytesAvailable:
+      ABSL_FALLTHROUGH_INTENDED;
+    case kCFStreamEventEndEncountered:
+      self->read_event_.SetReady();
+      break;
+    case kCFStreamEventErrorOccurred: {
+      auto status = CFErrorToStatus(CFReadStreamCopyError(stream));
+      GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStream Read error: %s",
+                                       status.ToString().c_str());
+
+      self->open_event_.SetShutdown(status);
+      self->read_event_.SetShutdown(status);
+      self->write_event_.SetShutdown(status);
+    } break;
+    default:
+      GPR_UNREACHABLE_CODE(return);
+  }
+}
+
+/* static */
+void CFStreamEndpointImpl::WriteCallback(CFWriteStreamRef stream,
+                                         CFStreamEventType type,
+                                         void* client_callback_info) {
+  auto self = static_cast<CFStreamEndpointImpl*>(client_callback_info);
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
+      "CFStreamEndpointImpl::WriteCallback, type: %lu, this: %p", type, self);
+
+  switch (type) {
+    case kCFStreamEventOpenCompleted:
+      self->open_event_.SetReady();
+      break;
+    case kCFStreamEventCanAcceptBytes:
+      ABSL_FALLTHROUGH_INTENDED;
+    case kCFStreamEventEndEncountered:
+      self->write_event_.SetReady();
+      break;
+    case kCFStreamEventErrorOccurred: {
+      auto status = CFErrorToStatus(CFWriteStreamCopyError(stream));
+      GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStream Write error: %s",
+                                       status.ToString().c_str());
+
+      self->open_event_.SetShutdown(status);
+      self->read_event_.SetShutdown(status);
+      self->write_event_.SetShutdown(status);
+    } break;
+    default:
+      GPR_UNREACHABLE_CODE(return);
+  }
+}
+
+CFStreamEndpointImpl::CFStreamEndpointImpl(
+    std::shared_ptr<CFEventEngine> engine, MemoryAllocator memory_allocator)
+    : engine_(std::move(engine)),
+      memory_allocator_(std::move(memory_allocator)),
+      open_event_(engine_.get()),
+      read_event_(engine_.get()),
+      write_event_(engine_.get()) {
+  open_event_.InitEvent();
+  read_event_.InitEvent();
+  write_event_.InitEvent();
+}
+
+CFStreamEndpointImpl::~CFStreamEndpointImpl() {
+  open_event_.DestroyEvent();
+  read_event_.DestroyEvent();
+  write_event_.DestroyEvent();
+}
+
+void CFStreamEndpointImpl::Shutdown() {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Shutdown: this: %p",
+                                   this);
+
+  auto shutdownStatus =
+      absl::Status(absl::StatusCode::kUnknown,
+                   absl::StrFormat("Shutting down CFStreamEndpointImpl"));
+  open_event_.SetShutdown(shutdownStatus);
+  read_event_.SetShutdown(shutdownStatus);
+  write_event_.SetShutdown(shutdownStatus);
+
+  CFReadStreamSetClient(cf_read_stream_, kCFStreamEventNone, nullptr, nullptr);
+  CFWriteStreamSetClient(cf_write_stream_, kCFStreamEventNone, nullptr,
+                         nullptr);
+  CFReadStreamClose(cf_read_stream_);
+  CFWriteStreamClose(cf_write_stream_);
+}
+
+bool CFStreamEndpointImpl::Read(
+    absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
+    const EventEngine::Endpoint::ReadArgs* /* args */) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Read, this: %p",
+                                   this);
+
+  read_event_.NotifyOn(new PosixEngineClosure(
+      [that = Ref(), on_read = std::move(on_read),
+       buffer](absl::Status status) mutable {
+        if (status.ok()) {
+          that->DoRead(std::move(on_read), buffer);
+        } else {
+          on_read(status);
+        }
+      },
+      false /* is_permanent*/));
+
+  return false;
+}
+
+void CFStreamEndpointImpl::DoRead(
+    absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::DoRead, this: %p",
+                                   this);
+
+  auto buffer_index = buffer->AppendIndexed(
+      Slice(memory_allocator_.MakeSlice(kDefaultReadBufferSize)));
+
+  CFIndex read_size = CFReadStreamRead(
+      cf_read_stream_,
+      internal::SliceCast<MutableSlice>(buffer->MutableSliceAt(buffer_index))
+          .begin(),
+      kDefaultReadBufferSize);
+
+  if (read_size < 0) {
+    auto status = CFErrorToStatus(CFReadStreamCopyError(cf_read_stream_));
+    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStream read error: %s, read_size: %ld",
+                                     status.ToString().c_str(), read_size);
+    on_read(status);
+    return;
+  }
+
+  buffer->RemoveLastNBytes(buffer->Length() - read_size);
+  on_read(absl::OkStatus());
+}
+
+bool CFStreamEndpointImpl::Write(
+    absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data,
+    const EventEngine::Endpoint::WriteArgs* /* args */) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Write, this: %p",
+                                   this);
+
+  write_event_.NotifyOn(new PosixEngineClosure(
+      [that = Ref(), on_writable = std::move(on_writable),
+       data](absl::Status status) mutable {
+        if (status.ok()) {
+          that->DoWrite(std::move(on_writable), data);
+        } else {
+          on_writable(status);
+        }
+      },
+      false /* is_permanent*/));
+
+  return false;
+}
+
+void CFStreamEndpointImpl::DoWrite(
+    absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::DoWrite, this: %p",
+                                   this);
+
+  size_t total_written_size = 0;
+  for (size_t i = 0; i < data->Count(); i++) {
+    auto slice = data->RefSlice(i);
+    size_t written_size =
+        CFWriteStreamWrite(cf_write_stream_, slice.begin(), slice.size());
+
+    total_written_size += written_size;
+    if (written_size < slice.size()) {
+      SliceBuffer written;
+      data->MoveFirstNBytesIntoSliceBuffer(total_written_size, written);
+
+      write_event_.NotifyOn(new PosixEngineClosure(
+          [that = Ref(), on_writable = std::move(on_writable),
+           data](absl::Status status) mutable {
+            if (status.ok()) {
+              that->DoWrite(std::move(on_writable), data);
+            } else {
+              on_writable(status);
+            }
+          },
+          false /* is_permanent*/));
+      return;
+    }
+  }
+  on_writable(absl::OkStatus());
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE