Robert Roeser

This commit introduces a **new capability** to the **Thrift C++2 protocol serialization subsystem**, allowing users to provide an existing `IOBuf` as a prefix buffer for write operations, thereby eliminating new memory allocations. Specifically, the `CursorWriteOpts` structure in `thrift/lib/cpp2/protocol/CursorBasedSerializer.h` gains a `prefix` option, and the `writer` method is updated to utilize this pre-allocated buffer. This **feature addition** also includes necessary adjustments to `DynamicCursorSerializationWrapper` and comprehensive **new test cases** in `CursorBasedSerializerTest.cpp` to validate the `prefix` buffer functionality. The change primarily impacts the **Thrift C++2 protocol's efficiency**, enabling **zero-allocation writes** when a pre-existing buffer is available.

This commit **adds comprehensive move semantics support** to the **`SmallBuffer` utility** located in `thrift/lib/cpp2/dynamic/detail/SmallBuffer.h`. This **new feature** introduces move constructors, move assignment operators, and a `MoveOnly` template parameter, enabling `SmallBuffer` to efficiently handle types that are not copyable. Additionally, `reset()` and `empty()` methods have been implemented to improve state management for the buffer. The changes are thoroughly validated by **new test cases** in `SmallBufferTest.cpp`, which cover move semantics, empty state handling, and the behavior of the `MoveOnly` parameter. This enhancement improves the flexibility and resource efficiency of `SmallBuffer` for dynamic Thrift components.

This commit initiates a significant **refactoring** of the **Thrift C++ Rocket transport server** to enhance its handling of `REQUEST_CHANNEL` frames and `RocketSinkClientCallback` instances. It introduces a new `RequestChannelHandler` responsible for processing `REQUEST_CHANNEL` frames, including partial ones, and a `SinkCallbackManager` to centralize the lifecycle management of sink client callbacks, including creation, freeing, and timeout scheduling. The `RefactoredRocketServerConnection` and `IncomingFrameHandler` are updated to integrate these new components, improving the server's ability to manage complex stream interactions and sink operations. This work provides **new capabilities** for stream management and lays the groundwork for more robust and organized stream processing within the Rocket server.

This commit introduces **initial stream support** for the **Thrift C++2 Rocket transport server**, significantly enhancing its capability to handle streaming RPCs. It involves a **refactoring** of the server's frame processing logic, integrating new dedicated handlers like `ExistingStreamFrameHandler`, `RequestStreamHandler`, and `StreamCallbackManager`. The `RefactoredRocketServerConnection` and `ConnectionAdapter` are updated to delegate stream lifecycle management and expose stream-related functionalities. This **new capability** allows the server to correctly process `REQUEST_STREAM`, `REQUEST_N`, `CANCEL`, `EXT`, `PAYLOAD`, and `REQUEST_FNF` frames, improving support for long-lived, multi-response operations.

This commit **re-introduces stream pausing and resuming support** within the **Thrift C++2 Rocket transport server**. It specifically enhances the `ConnectionAdapter` by adding new methods such as `incrementActivePausedHandlers`, `decrementActivePausedHandlers`, `setSocketReadCallback`, and `clearSocketReadCallback`. This **feature addition** provides granular control over active paused read handlers and socket read callbacks, enabling more robust management of data flow for Rocket connections. The changes are confined to the `thrift/lib/cpp2/transport/rocket/server/detail/ConnectionAdapter.h` file, impacting how server-side connections handle data stream control.

This commit **reintroduces metadata push support** within the **Thrift Rocket server transport**. It introduces a new `MetadataPushHandler` class, responsible for processing various client-initiated metadata frames. The `RefactoredRocketServerConnection` now integrates this handler, passing it to the `IncomingFrameHandler` which is updated to specifically process `METADATA_PUSH` frames. This **new feature** enhances the server's capability to react to client-driven metadata updates, improving overall communication flexibility.

This commit introduces **keep-alive support** to the **Thrift Rocket server transport**, enhancing connection stability and reliability. It integrates a new `KeepAliveHandler` into the `RefactoredRocketServerConnection` to manage and respond to keep-alive frames. The `IncomingFrameHandler` is updated to process these frames, and `ConnectionAdapter` gains a new `sendFrame` method to facilitate their transmission. This **new feature** allows the server to actively maintain connections and detect unresponsive clients more effectively.

This commit performs a **performance optimization** and **refactoring** of the **Thrift Rocket server transport**. It primarily focuses on improving **memory layout and cache locality** within critical components like `RefactoredRocketServerConnection` and `IncomingFrameBatcher`. Key changes include reordering member variables, caching frequently accessed pointers to reduce `EventBaseLocal` lookup overhead, and streamlining data structures like `RingBuffer`. Additionally, it enhances the **robustness** of frame parsing and connection handling logic in `ConnectionAdapter` and `IncomingFrameHandler`. This work aims to boost the overall efficiency and stability of the **Thrift Rocket server**.

This commit **refactors** the **Thrift Rocket server's write batching mechanism** to enhance performance by replacing `std::map` operations with an **intrusive list**. This change primarily affects the **I/O batching subsystem**, where `ConnectionAdapter` is updated to integrate `IOBufQueue` and intrusive list hooks for efficient pending write management. The `OutgoingFrameHandler` is subsequently modified to leverage this new intrusive list for processing connections with buffered writes, eliminating costly map lookups. Additionally, the `WriteBatcher` component is optimized by switching to `IOBufQueue` for improved append performance, collectively providing a significant **performance optimization** for the server's I/O handling.

This commit introduces a significant **performance optimization** for the **Thrift C++2 Rocket transport server** by refactoring its outgoing frame batching mechanism. Previously, batching occurred per individual connection, which was inefficient for low-frequency request patterns; now, batching is performed **per `eventbase` instance**. This change allows `RefactoredRocketServerConnection` to aggregate outgoing frames from multiple connections within a single event loop tick, drastically **reducing the number of `async socket` write calls**. The `OutgoingFrameHandler` is refactored to support this per-eventbase batching, processing `SerializationEvent`s more efficiently and improving server throughput and reducing CPU overhead by encouraging more effective batching across the entire `eventbase`.

This commit introduces a significant **performance optimization** for the **Thrift Rocket server transport** by enhancing its outgoing frame batching capabilities. The `OutgoingFrameHandler` is now able to directly batch and flush outgoing frames, collecting write events for more efficient I/O operations. This change refactors the frame sending methods within `RefactoredRocketServerConnection.cpp` to conditionally leverage this new batching mechanism, controlled by a feature flag. Additionally, several related files like `ConnectionAdapter.h` and `WriteBatcher.h` undergo **refactoring** to centralize type definitions in `WriteBatchTypes.h`, streamlining the batching infrastructure. This improvement aims to reduce overhead and improve throughput for Rocket server connections.

This commit performs a significant **refactoring** of the **RSocket server connection** (`RefactoredRocketServerConnection`) to improve its architecture, testability, and performance. It introduces a `ConnectionAdapter` to break cyclic dependencies and modularizes frame handling into specialized components like `IncomingFrameHandler`, `SetupFrameAcceptor`, and `RequestResponseHandler`. Crucially, it adds **incoming and outgoing frame batching** tied to the `EventBase`, enhancing performance by processing operations across multiple connections more efficiently. Write operations are also refactored into modular callbacks (`ConnectionWriterCallback`, `ConnectionBufferCallback`) and a `WriteBatcher` for better separation of concerns. This comprehensive **refactoring** results in a more robust and maintainable RSocket server implementation.

add rocketserverconnectionfactory to the cmake file

This commit introduces a **new `RocketServerConnectionFactory`** to **decouple the creation of `IRocketServerConnection` instances** within the **Thrift Rocket server transport**. The `RocketRoutingHandler`'s `handleConnection` method is **refactored** to utilize this factory, centralizing the logic for instantiating server connections. This **new capability** enhances modularity and flexibility by abstracting connection setup, also adding a `parserStrategy` field to `IRocketServerConnection::Config` for potential future customization of parsing behavior. The change improves the extensibility and maintainability of the Rocket server's connection management.

This commit performs a significant **refactoring** within the **Thrift Rocket transport server** by introducing and widely adopting the **`IRocketServerConnection`** interface. The concrete **`RocketServerConnection`** class is updated to inherit from this new interface, and numerous related server-side components, callbacks, and handlers are modified to interact with the connection via `IRocketServerConnection` instead of the concrete type. This change improves the **extensibility** and **testability** of the Rocket transport by enabling different implementations of the server connection to be easily swapped. The scope of this update spans core server logic, various client callbacks, frame handling, and associated test utilities, enhancing the overall **architectural flexibility**.

This commit performs a significant **refactoring** within the **Thrift Rocket transport server** by introducing the `IRocketServerConnection` interface. The `RocketServerConnection` class is updated to **implement this new interface**, adding `override` specifiers to its virtual methods and declaring new `pauseSocketReading` and `tryResumeSocketReading` methods. This change enables **future flexibility** to swap out different `RocketServerConnection` implementations, enhancing the extensibility of the server connection architecture. While introducing new control mechanisms, this is a **net-zero functional change** that lays the groundwork for alternative implementations without altering current behavior.

This commit introduces the **`IRocketServerConnection` interface** within the **Thrift Rocket server transport** to facilitate future refactoring of the `RocketServerConnection` class. This **new capability** defines a comprehensive set of virtual methods for managing server connections, encompassing stream handling, I/O operations, and lifecycle events. By establishing this interface, the project gains the flexibility to swap out different `RocketServerConnection` implementations, enabling more modular and testable code for the **Rocket server connection management**. A minor adjustment was also made to `RocketServerConnection.h` to align with this architectural preparation.

This commit introduces a **new `RingBuffer` data structure** (`thrift/lib/cpp2/transport/rocket/core/RingBuffer.h`) specifically designed to enhance the **performance** of the **Thrift Rocket RPC transport layer**. This **new capability** provides a highly optimized, single-threaded ring buffer that prioritizes predictable memory allocation, cache locality, and no-throw guarantees, unlike standard STL containers. Its primary purpose is to enable **batch consumption** via `consume()` to **amortize costs** associated with operations like socket writing and frame serialization/deserialization. This optimization aims to improve overall **throughput and latency** in high-performance scenarios within **Thrift Rocket RPC**. Comprehensive unit tests and benchmarks (`RingBufferTest.cpp`, `RingBufferBenchmark.cpp`) are included to validate its functionality and performance.

This commit introduces a **type-safe trait system** for **Rocket frames** within the `thrift/lib/cpp2/transport/rocket/core` module, primarily through the new `FrameUtil.h` header. This **new feature** enables compile-time determination of frame properties, such as streaming type and stream ID 0, eliminating the need for runtime type checks. It provides a robust mechanism, including `FrameContainer` and `FrameTraits`, for managing the lifecycle, serialization, and deserialization of diverse Rocket frame types. This architectural improvement significantly enhances the **efficiency and static verification** of frame handling, supporting various Rocket frame semantics like streaming and control frames.

This commit introduces **preparatory refactoring** and **minor enhancements** within the **Thrift Rocket transport layer**, specifically targeting its framing and serialization components. It **updates the `KeepAliveFrame` structure** by adding a `streamId_` member and its corresponding initialization, while also removing an unused include from `Frames.h`. Additionally, the **`Serializer` class** gains a new `moveAndReset` method for efficient buffer handling and a `FOLLY_SAFE_DCHECK` in `writePayload` to improve runtime safety. These changes are foundational, setting the stage for a larger **`RocketServerConnection` refactor**.