refactor: send larger messages properly (#455)

Until now, the solution to ensure that even large messages are fully sent out has been to flush the connection queues after each sending of a message, which is likely an unnecessary call (with unnecessary cost) in vast majority of cases, and which may block the connection from doing other work until the large message is fully sent out. This was a rather quick, hacky workaround.

Now, after the sending the message we check whether it has been sent out fully or not. If not (outbound queues are non-empty), then we send a wake-up signal to the connection event loop. The event loop thread then fetches new sd-bus timeouts and events and will see that there are pending outbound messages to process, and will process them together with any other prospective pending events, until there is nothing to process (i.e., the outbound message has been fully dispatched).

tests/integrationtests/TestAdaptor.cpp

@@ -128,6 +128,14 @@ uint32_t TestAdaptor::doOperation(const uint32_t& param)
     return param;
 }
 
+std::map<int32_t, std::string> TestAdaptor::doOperationWithLargeData(const std::map<int32_t, std::string>& largeParam)
+{
+    m_methodCallMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
+    m_methodName = m_methodCallMsg->getMemberName();
+
+    return largeParam;
+}
+
 void TestAdaptor::doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t param)
 {
     m_methodCallMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
@@ -149,6 +157,27 @@ void TestAdaptor::doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t pa
     }
 }
 
+void TestAdaptor::doOperationAsyncWithLargeData(sdbus::Result<std::map<int32_t, std::string>>&& result, uint32_t param, const std::map<int32_t, std::string>& largeMap)
+{
+    m_methodCallMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
+    m_methodName = m_methodCallMsg->getMemberName();
+
+    if (param == 0)
+    {
+        // Don't sleep and return the result from this thread
+        result.returnResults(largeMap);
+    }
+    else
+    {
+        // Process asynchronously in another thread and return the result from there
+        std::thread([param, largeMap, result = std::move(result)]()
+                    {
+                        std::this_thread::sleep_for(std::chrono::milliseconds(param));
+                        result.returnResults(largeMap);
+                    }).detach();
+    }
+}
+
 sdbus::Signature TestAdaptor::getSignature()
 {
     return SIGNATURE_VALUE;
@@ -212,6 +241,11 @@ void TestAdaptor::emitTwoSimpleSignals()
     emitSignalWithMap({});
 }
 
+void TestAdaptor::sendLargeMessage(const std::map<int, std::string>& /*collection*/)
+{
+    //printf("Adaptor: got collection with %zu items", collection.size());
+}
+
 std::string TestAdaptor::state()
 {
     return m_state;