Fix flaky OverloadTest::Test by using Baton synchronization

Summary:
The test was flaky because it used a race-prone polling loop with `std::this_thread::yield()` to wait for a request to become active. This approach had several issues:

1. No timeout/deadline - could loop infinitely in edge cases
2. Race condition - checking `getActiveRequests() >= 1` doesn't guarantee the request has actually entered the blocking handler
3. Very short queue timeout (10ms) that could race with the polling

Fix by using explicit `folly::Baton` synchronization:
- Added an `entered` baton to `BlockInterface` that signals when a request has entered `voidResponse()`
- Use `try_wait_for(5s)` instead of spin-waiting with yield
- Increased queue timeout to 1s since synchronization is now explicit

Reviewed By: tlj77

Differential Revision: D94309711

fbshipit-source-id: 9cafb07a8ef1a4682f330c5d4bac17387b730800

Author: sazonovkirill

third-party/thrift/src/thrift/lib/cpp2/test/server/ThriftServerTest.cpp

@@ -2057,20 +2057,24 @@ INSTANTIATE_TEST_CASE_P(
     HeaderOrRocket,
     testing::Values(TransportType::Header, TransportType::Rocket));
 
-// DO_BEFORE(aristidis,20250716): Test is flaky. Find owner or remove.
-TEST_P(OverloadTest, DISABLED_Test) {
+TEST_P(OverloadTest, Test) {
   class BlockInterface : public apache::thrift::ServiceHandler<TestService> {
    public:
     folly::Baton<> block;
-    void voidResponse() override { block.wait(); }
+    folly::Baton<> entered;
+    void voidResponse() override {
+      entered.post();
+      block.wait();
+    }
 
     void async_eb_eventBaseAsync(
         HandlerCallbackPtr<std::unique_ptr<::std::string>> callback) override {
       callback->appOverloadedException("method loadshedding request");
     }
   };
 
-  ScopedServerInterfaceThread runner(std::make_shared<BlockInterface>());
+  auto handler = std::make_shared<BlockInterface>();
+  ScopedServerInterfaceThread runner(handler);
   folly::EventBase base;
   auto client = makeClient(runner, &base);
 
@@ -2094,20 +2098,15 @@ TEST_P(OverloadTest, DISABLED_Test) {
     return {};
   });
 
-  // force overloaded
   folly::Function<void()> onExit = [] {};
   auto guard = folly::makeGuard([&] { onExit(); });
   if (errorType == ErrorType::Overload) {
-    // Thrift is overloaded on max requests
     runner.getThriftServer().setMaxRequests(1);
-    runner.getThriftServer().setQueueTimeout(10ms);
-    auto handler = dynamic_cast<BlockInterface*>(
-        runner.getThriftServer().getProcessorFactory().get());
+    runner.getThriftServer().setQueueTimeout(1s);
     client->semifuture_voidResponse();
-    while (runner.getThriftServer().getActiveRequests() < 1) {
-      std::this_thread::yield();
-    }
-    onExit = [handler] { handler->block.post(); };
+    ASSERT_TRUE(handler->entered.try_wait_for(5s))
+        << "Timed out waiting for blocking request to enter handler";
+    onExit = [&handler] { handler->block.post(); };
   }
 
   RpcOptions rpcOptions;