Robert Roeser

Add synchronous Rust handler integration Summary: Build the synchronous Rust handler bridge on top of the native channel_pipeline readiness primitives. Add borrowed callback contexts, message adapters, lifecycle and backpressure handling, panic containment, tests, benchmarks, and design documentation while keeping Rust dependencies opt-in. Reviewed By: pranavtbhat Differential Revision: D113432296 fbshipit-source-id: d14a9b4489ea136c34890b8b84e94eabebf95593

channel_pipeline coro support Summary: Builds on the move-only ContextHandle continuation from previous diff to let a Rust channel_pipeline handler be written as a coroutine instead of a synchronous callback. Adds CallbackContext::spawn, which starts a Send + 'static Rust future on the pipeline's own EventBase. The first poll runs inline in the current callback, so a future that is already ready never leaves the callback frame. If that poll returns Pending, later wakes schedule subsequent polls back onto the same EventBase. The task owns the existing ContextHandle, which retains the pipeline and its EventBase until completion or cancellation, and the completion closure consumes the handle to resume the pipeline from the exact captured position. Adds EventBaseTask (event_base.rs) as the future-to-EventBase bridge, backed by async-task. A BootstrapWake waker services the inline first poll and reconciles it with the async_task Runnable that is only created after that poll returns Pending; wakes arriving before, during, or concurrently with Runnable installation coalesce into exactly one scheduled poll. Both the inline poll and each scheduled poll are wrapped in catch_unwind so a panicking future cannot unwind across the FFI boundary. Extends the FFI surface with FfiCallbackContext::eventBase() and enqueueInEventBase, which moves a raw async_task Runnable through runInEventBaseThreadAlwaysEnqueue. The native side wraps the token in a move-only RAII Task carrying both the call and drop thunks, so an EventBase destroyed with the callback still queued cancels and drops the Rust future exactly once rather than leaking it. Adds CoroReadHandle, CoroWriteHandle, and CoroExceptionHandle adapters plus the ContextReadMessage and ContextWriteMessage traits (implemented for BytesPtr) so a handler body can be an async closure over the message or error. Updates the RustHandler documentation, which previously stated that async work was unsupported. Reviewed By: pranavtbhat Differential Revision: D114866635 fbshipit-source-id: 0efd42a352845e9e647126c60ad0258ef409fe4c

context handle for async integration Summary: Adds idiomatic async support to channel_pipeline through two composable, pay-for-use APIs. - Introduces a move-only, one-shot ContextHandle for callback, worker-thread, and other async code. It retains the pipeline across asynchronous work and resumes read, write, or exception processing at the correct handler position on the originating EventBase. - Adds coro::ContextHandle with allocation-free direct awaitables: co_fireRead, co_fireWrite, and co_fireException. Read and write return the actual downstream Result, and the awaiting coroutine resumes on the pipeline EventBase. - Keeps coroutine dependencies isolated from the base pipeline. Existing synchronous handlers and dispatch paths incur no additional runtime cost. - Defines safe behavior when the pipeline closes while work is outstanding: base operations are dropped, while coroutine read and write operations complete with Result::Error. - Adds comprehensive routing, concurrency, ownership, cancellation, destruction, sanitizer, and performance coverage. Reviewed By: pranavtbhat Differential Revision: D113107531 fbshipit-source-id: a4719ca74c5fd9283fe1aa0e7097fe45706ec82a

add ContextImpl to onWrite and onRead for tail and head adapters Summary: - Update head endpoint onWrite and tail endpoint onRead to receive detail::ContextImpl& alongside the message. - Add stable, pipeline-owned boundary contexts and wire their data-path propagation for empty and non-empty pipelines. - Migrate fast_thrift endpoint implementations, tests, and benchmarks to the two new data callback signatures without changing lifecycle, readiness, exception, or event callback contracts. Differential Revision: D115133484 fbshipit-source-id: 7a5e9600d2dfd6931dfdfe44918fa802305871d0

add proper Rust continuation support to the channel_pipe Summary: Adds a production-ready Rust ContextHandle continuation for fast_thrift channel pipelines. The move-only, two-word handle retains the exact pipeline position and can safely cross threads; RAII destruction releases its native guard inline on the EventBase or schedules it back there when dropped elsewhere. Exposes consuming fire_read, fire_write, and fire_exception operations with immediate execution on the EventBase and queued execution from worker threads. Read/write preserve zero-copy IOBuf ownership and exception delivery uses an owned Rust PipelineError converted to folly::exception_wrapper. All continuations suppress delivery after pipeline closure and retain the pipeline until completion. Optimizes the EventBase-local data path to avoid constructing a heap-backed folly::Function. The complete local continuation path is zero-allocation and benchmarks at roughly 85-90 ns. Adds lifecycle, cross-thread, exact-position C++/Rust/C++ sandwich, request-context, message-boundary, concurrency, close-race, and exception-preservation coverage. Reviewed By: pranavtbhat Differential Revision: D114833642 fbshipit-source-id: 5ab25e93e795580b5485089bec83d7acc5096d47

fix rust handler so that it properly erases types Summary: builds parity with C++ handlers so that it supports moving type erased messages Reviewed By: pranavtbhat Differential Revision: D114279415 fbshipit-source-id: c7e2422287b93b50cbb04513d481a1219313868d

head write-ready API for channel_pipeline Summary: channel_pipeline delivered write-ready only to middle handlers and the tail endpoint: handlerWriteReadyHook() returned nullptr past the handler list, so a head endpoint (transport) could neither await write capacity nor observe the write-ready edge, and kernel backpressure such as send-queue saturation could not propagate back through the pipeline. This adds optional head-endpoint write-ready support: - PipelineBuilder wires HeadHandler::onWriteReady when the head provides it (detected with requires; heads that don't are unchanged). - PipelineImpl tracks a headWriteReadyHook_ owned by the pipeline (handlerIndex = N, outside the handler list), with an isHeadWriteBackpressured() query and a handlerWriteReadyHook() fallback for index N. - Write-ready dispatch is re-entrant safe and head-first: the head consumes the edge before upstream handlers retry so they observe updated transport state; a re-armed head hook blocks upstream propagation for that pass; re-entrant onWriteReady during dispatch coalesces via writeReadyDispatchPending_ instead of recursing; per-generation marking restarts list inspection after every callback so no iterator survives arbitrary hook mutation. Differential Revision: D118671251 fbshipit-source-id: 7b1fb2681d76dada2a881ff5160a735b3cc1d273

Add channel pipeline readiness primitives Summary: Add the native channel_pipeline lifecycle, readiness, and backpressure primitives required by synchronous foreign-language handlers. Keep these changes independent of Rust and preserve zero cost for existing native pipelines. Differential Revision: D113432294 fbshipit-source-id: 78e1d50c0a977fb1e8103986f7b7d53a9b543a38

fix directstreammap erasure Summary: `DirectStreamMap` ordered erasure performs quadratic work **Location:** `/data/users/rroeser/fbsource/fbcode/thrift/lib/cpp2/fast_thrift/frame/read/DirectStreamMap.h:188-205` **Frequency:** Once per terminal stream removal on client and server Rocket stream tables. `StreamIdIndex` maps normal same-parity RSocket stream IDs into consecutive natural slots. `eraseSlot()` nevertheless scans forward until the first empty slot, even when no entry is displaced and no backshift is possible. For `N` naturally placed streams erased in stream-ID order, the implementation performs exactly: ```text N * (N - 1) / 2 ``` Differential Revision: D117670393 fbshipit-source-id: 47813b59bb5b3df5517a6ceeef73127b7c6244e0

Size metadata buffers to serialized payloads Summary: Allocate request and response metadata buffers from the protocol writer computed serialized size instead of enforcing a 1 KiB minimum. Preserve the 16-byte frame-header headroom required by the zero-allocation frame serialization path while avoiding oversized allocations for typical small metadata. Add coverage for request Binary metadata and response Binary and Compact metadata. Differential Revision: D117535165 fbshipit-source-id: 62e6d00310b38d183c8567b721c82854554e6c64