Rashmi Makheja

This commit introduces a **new capability** to **Thrift's server-side bidirectional streaming** by adding a callback-based constructor to `ServerBiDiStreamFactory`. This enables **non-coroutine based server runtimes, such as HHVM**, to directly access and manage stream and sink bridge pointers via a new `ServerBiDiCallback` interface, bypassing the `StreamTransformation` pattern. Additionally, the `ServerBiDiStreamBridge` and `ServerBiDiSinkBridge` components are updated to use `QueueConsumer` instead of `CoroConsumer`, further **broadening compatibility for diverse server environments** that do not rely on coroutines. These changes collectively **improve the flexibility and integration** of Thrift's asynchronous bidirectional streaming for a wider range of server architectures.

This commit **fixes conformance tests** within the **Thrift RPC framework** to correctly handle and compare **undeclared exceptions**. It **enhances the `RpcStructComparator`** by adding specific comparison logic for undeclared exceptions occurring in **bidirectional (bidi) methods, bidi streams, and bidi sinks**, ensuring accurate validation of these complex RPC types. Furthermore, the changes in `thrift/conformance/GTestHarness.cpp` adjust exception message extraction for bidi methods and improve assertion failure output, providing clearer test results. This **maintenance** work significantly improves the reliability and accuracy of the **Thrift conformance testing suite**, especially for exception handling in advanced RPC patterns.

This commit **introduces new conformance tests** to validate the handling of both declared and undeclared exceptions in **bidirectional streaming RPCs**. It **extends the `thrift/conformance` testing framework** by adding client and server-side logic, test case generation, and Thrift interface definitions for these specific bidi stream exception scenarios. The changes ensure that various language implementations, including C++ and Rust, correctly process exceptions during streaming operations, thereby **improving the reliability and interoperability** of Thrift's bidi stream functionality. This work is a **new capability** focused on **enhancing test coverage** for critical RPC patterns.

This commit **adds comprehensive conformance tests** for **bidi sink declared and undeclared exceptions** within the `thrift/conformance` module. It introduces new Thrift IDL definitions in `rpc.thrift`, implements corresponding client and server logic in C++ (`RPCClient.cpp`, `GTestHarnessRPCClient.cpp`, `RPCServerConformanceHandler.cpp`), and integrates these tests into the `GTestHarness.cpp` framework. This **new capability** significantly expands the **Thrift conformance suite**, ensuring robust and consistent behavior of bidi sink exception handling across different language implementations. The work involves defining new test cases in `RPCGenerator.cpp` and updating `nonconforming.txt` to track implementations that do not yet pass these new exception tests, such as the Rust client.

This commit implements a **new conformance test suite** for **bidirectional (BiDi) streaming** within the Thrift framework. It introduces new Thrift definitions in `thrift/conformance/if/rpc.thrift` and adds the necessary test logic, data generation, and helper functions to the `thrift/conformance` module. This **test infrastructure enhancement** enables the validation of basic BiDi streaming scenarios by implementing the `co_bidiBasic` method in both RPC client and server conformance handlers. The work establishes a critical foundation for ensuring the correctness and compatibility of BiDi streaming across various Thrift language implementations, including C++, Python, and Hack.

This commit **introduces new conformance tests** within the **Thrift RPC testing framework** to validate the behavior of **bidirectional streaming initial responses** and **method exception handling**. It involves extensive updates across the `thrift/conformance` module, including new test definitions in `rpc.thrift`, client-side test implementations in `RPCClient.cpp`, and server-side handlers in `RPCServerConformanceHandler.cpp`. This **enhancement** provides critical test coverage for complex RPC scenarios, ensuring that different Thrift language implementations correctly handle these communication patterns. The new tests, integrated via `GTestHarness.cpp`, will help identify and resolve inconsistencies, thereby **improving the robustness and interoperability** of Thrift services.

This commit **fixes a bug** in the **Java code generator** within the **Thrift compiler** that previously caused invalid code generation for **bidirectional streaming methods**. Specifically, the `t_mstch_java_generator.cc` module is updated to correctly distinguish and **skip** bidirectional stream methods when processing regular streaming or sink functions, preventing unbuildable Java output. This **bug fix** is essential for proper **bidirectional streaming support** in Java and **unblocks the addition of conformance tests** for this feature, as demonstrated by the inclusion of new test fixtures for both Java and Hack.

This commit delivers a **bug fix** to resolve **HHVM crashes** occurring within the **Thrift Client sink** mechanism. The issue stemmed from an incorrect handling of sink completion signals, where an empty `folly::Try<StreamPayload>` was being sent instead of the required `StreamMessage::Complete{}` after a recent protocol update. To rectify this, the `thrift/lib/cpp2/async/ClientSinkBridge.cpp` file is updated, specifically in the `push` and `processServerMessages` functions, to **modify the sink message handling** to correctly send and process `StreamMessage::Complete{}` for empty payloads. This ensures the **Thrift client** properly manages stream termination, preventing further runtime failures.

This commit **enhances the testing infrastructure** for the **Hack Thrift client library** by adding comprehensive integration tests for **streaming and sink functionalities** within `TClientAsyncHandler`. New test classes and methods are introduced in `thrift/lib/hack/src/__tests__/TClientAsyncHandlerTest.php` and `thrift/lib/hack/src/__tests__/ThriftProcessorStreamingEventHandlerTest.php` to validate these advanced communication patterns. To facilitate these tests, a new `testSink` method is also added to the `ExampleStreamingService` in the `thrift/lib/hack/src/if/ExampleThriftService.thrift` definition. This **testing enhancement** ensures the **robustness and correctness** of Thrift's asynchronous streaming and sink operations when using the `TClientAsyncHandler` in Hack.

This commit introduces a **new capability** to the **Thrift PHP client**, allowing **stream and sink methods** to operate without requiring an explicit channel. It achieves this by adding `genWaitStream()` and `genWaitSink()` methods to `TClientAsyncHandler` and `TClientMultiAsyncHandler`, which provide an async generator or sink function as a fallback. The `ThriftClientBase` is updated to leverage these new async handler methods within `genAwaitStreamResponse()` and `genAwaitSinkResponse()` when a channel is not present, relaxing previous invariant checks. This enhancement provides **more flexible client configurations** and enables stream/sink operations in environments where traditional channels may be unavailable, such as FAAS setups.

This commit introduces a **performance optimization** to the **Thrift serialization subsystem** by enabling the use of faster struct-to-string read/write extensions for accelerated protocols. It modifies the **`TBinaryProtocolAccelerated` and `TCompactProtocolAccelerated` implementations** to conditionally leverage these optimized methods for RPC message and struct serialization when operating with `TMemoryBuffer`. This **new capability**, gated by the `useStructToStringRPCHelpers` function and a "JK" mechanism, aims to provide **significant speed improvements** for client/server communication by utilizing more efficient serialization paths for the core message content. The change ensures the message envelope is still handled by the standard PHP implementation while the actual message benefits from the accelerated extensions.

This commit introduces a significant **refactoring** of the **Thrift RPC serialization logic** within the `thrift/lib/hack` library. It consolidates protocol-specific serialization code in `ThriftClientBase.php` and `ThriftProcessorBase.php` by replacing it with unified calls to common RPC serialization helpers, specifically impacting methods like `sendImpl`, `recvImpl`, `readMessage`, and `writeMessage`. A new static helper `useCommonRPCHelpers` is added to `ThriftSerializationHelper.php` to control this change via a JustKnob, enabling a controlled rollout. This **reduces code duplication**, simplifies maintenance of RPC serialization across different protocols and client/server components, and prepares the system for future extensions, with **updated tests** ensuring correct behavior across both old and new serialization paths.

This commit introduces **new helper methods** to the **Thrift protocol layer** for more streamlined reading and writing of RPC messages and structs. The `TProtocol` base class gains `writeRPCMessage()`, `readRPCMessage()`, `writeRPCStruct()`, and `readRPCStruct()`, with accelerated versions implemented in `TBinaryProtocolAccelerated` and `TCompactProtocolAccelerated` that delegate to native implementations. This **new capability** aims to **reduce boilerplate** in client/processor code and provide a consistent interface for RPC serialization/deserialization across different protocol implementations. Test coverage for `writeRPCStruct()` and `readRPCStruct()` is also added for both binary and compact protocols, ensuring the reliability of these new utilities. These helpers will simplify common RPC patterns in future changes.

This commit performs **maintenance** and **cleanup** within the **Hack type system's union conformance testing**. It **removes specific test cases** from a "nonconformant list," as **Hack unions** are now **conformant by default**. This update reflects the successful, widespread rollout of strict unions across the project's Thrift files, streamlining the test suite and ensuring the conformance checks accurately reflect the current state of the **Hack language**.

This commit introduces a **new test case** for the `TBinarySerializer` within the **Thrift Hack library**. Specifically, it adds a test to `thrift/lib/hack/src/protocol/binary/__tests__/TBinarySerializerTest.php` that verifies the correct **serialization and deserialization** of a complex struct. This **testing enhancement** improves the robustness and reliability of the `TBinarySerializer` component, ensuring accurate data handling for intricate data types in Hack-based Thrift applications.

This commit introduces a significant **performance optimization** for **Thrift binary serialization and deserialization** within the Hack environment. It refactors the `TBinarySerializer` to leverage faster, direct struct-to-string and string-to-struct methods, thereby eliminating unnecessary CPU overhead caused by intermediate protocol/buffer copying. The `ThriftStreamingSerializationHelpers` module is updated to conditionally enable these optimized paths, gated by a new `TBinarySerializer::useBinaryStruct()` method. This enhancement directly **reduces CPU usage** for services relying on `TBinarySerializer` by streamlining data handling, leading to more efficient data exchange.

This commit performs a **refactoring** across various **Thrift definitions** and their associated test files to standardize **legacy URI handling**. It introduces or updates `scope` and `thrift.uri` annotations within core **Thrift definitions** such as `RpcMetadata.thrift` and `frozen.thrift`, ensuring proper resolution for older URI schemes. Additionally, numerous **Rust and Python test Thrift files** are updated to align with these new annotation requirements. This **maintenance** effort also includes updates to **Rust Thrift build configurations** (`thrift_build.rs` files) to incorporate these annotations, improving consistency and compatibility across the Thrift ecosystem.

This commit **refactors** the **Thrift processing layer** in Hack by modifying the `processStreamRequest` method signature within `thrift/lib/hack/src/ThriftProcessorBase.php`. It introduces two new parameters, `_request_name` and `_handler_ctx`, to provide additional context during stream request handling. This **maintenance** change is a preparatory step for an **incremental rollout** aimed at updating the compiler version, ensuring that future compiler updates can leverage this enhanced request context for improved stability or functionality. The modification impacts how **Thrift stream requests** are processed, allowing for more detailed introspection or conditional logic based on the request's name and handler context.

This commit **enhances error handling for Thrift streaming services** by ensuring fatal exceptions are properly serialized and communicated to clients. It introduces a new error page and modifies `thrift/lib/hack/src/ThriftProcessorBase.php` to catch exceptions within the `genStream` method during active streams. These **streaming service fatal exceptions** are now sent directly via a dedicated streaming extension, bypassing the general Alite controller. This **enhancement** provides clients with access to deserialized `TApplicationException` messages, leading to **more robust error reporting and debugging** for streaming applications.

This commit introduces a **new feature** to the **Thrift streaming serialization helpers** in Hack, enabling direct serialization and deserialization of Thrift compact structs to and from strings for streaming payloads. This is achieved by adding `serializeStreamPayload` and `deserializeStreamPayload` methods within `ThriftStreamingSerializationHelpers.php`. A supporting **refactoring** was performed in `TCompactSerializer.php` to change the visibility of the `useCompactStruct` method from private to public, making it accessible for the new streaming logic. This enhancement streamlines the handling of streaming data by allowing payloads to be managed as simple strings.