mirror of
https://github.com/logos-co/logos-protocol.git
synced 2026-08-27 20:11:07 +00:00
Dario LipicarandClaude Opus 5
ae2f7e1b58
lp_client_create() made the CALLING thread the client's owner thread. Callers reach it through a lazily-created wrapper (the generated bind_<iface>() -> LpClient::ensure()), so the first thread to make an outbound call captured the whole transport for the life of the process. For the qt_remote transport that thread also ends up owning the QRemoteObjectNode and its QLocalSocket, which are only serviced by a thread running a Qt event loop. A module whose first call came from a worker — an HTTP handler, a timer thread — bound its transport to a thread that only pumps events while it is already blocked inside a call. Replica acquisition then never completed: every requestObject() burned its full 20s timeout and returned nullptr, and since a failed acquire yields an empty result the data loss was silent. openmetrics-module hit exactly this: one GET /metrics took 40s (2 x 20s) and came back missing a module, /health went unanswered behind the wedged libmicrohttpd thread, and the follow-up stop RPC failed. Construct the client on the Qt main thread when the transport needs a Qt event loop, so the per-call marshal that already exists (logos::runOnOwnerThread) lands somewhere that can actually service it. This is the anchor the Qt path always had — LogosAPI::getClient marshals construction to the LogosAPI's thread — given to the lp path. Plain (tcp/tcp_ssl) and mock transports are Qt-free and thread-agnostic, so they keep the calling thread: a worker-thread consumer stays off the main thread's back. LogosTransportFactory::needsQtEventLoop() carries that rule next to the createConnection resolution it mirrors. When there is nothing to anchor to (a Qt-affine transport with no QCoreApplication) we now warn instead of letting it surface as a mute timeout. Tests: a worker thread creates an lp client over qt_remote and calls a provider published on the main thread; passes in ~0.15s, and with the construction hop reverted fails after 24.8s / 49.9s — the acquire timeouts themselves. Plus a truth table for needsQtEventLoop. 183/183 protocol tests pass. Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
104 lines
3.8 KiB
C++
104 lines
3.8 KiB
C++
#include "logos_transport_factory.h"
|
|
#include "logos_transport.h"
|
|
#include "logos_mode.h"
|
|
#include "logos_transport_config.h"
|
|
#include "implementations/qt_local/local_transport.h"
|
|
#include "implementations/qt_remote/remote_transport.h"
|
|
#include "implementations/mock/mock_transport.h"
|
|
#include "implementations/plain/plain_transport_connection.h"
|
|
#include "implementations/plain/plain_transport_host.h"
|
|
|
|
#include <QDebug>
|
|
|
|
namespace LogosTransportFactory {
|
|
|
|
// Single resolution rule for both `createHost` overloads:
|
|
// LogosMode::Mock → MockTransportHost (cfg ignored)
|
|
// LogosMode::Local → LocalTransportHost (cfg ignored)
|
|
// LogosMode::Remote + LocalSocket → RemoteTransportHost (QRO)
|
|
// LogosMode::Remote + Tcp/TcpSsl → PlainTransportHost(cfg)
|
|
//
|
|
// Mode is consulted *first* so test fixtures setting Mock/Local always
|
|
// get the right transport regardless of which createHost overload (or
|
|
// LogosAPIProvider constructor) was used. The no-cfg overload below
|
|
// just delegates with `LogosTransportConfigGlobal::getDefault()` so
|
|
// there's exactly one path.
|
|
std::unique_ptr<LogosTransportHost>
|
|
createHost(const LogosTransportConfig& cfg, const QString& registryUrl)
|
|
{
|
|
if (LogosModeConfig::isLocal()) {
|
|
return std::make_unique<LocalTransportHost>();
|
|
}
|
|
if (LogosModeConfig::isMock()) {
|
|
return std::make_unique<MockTransportHost>();
|
|
}
|
|
switch (cfg.protocol) {
|
|
case LogosProtocol::Tcp:
|
|
case LogosProtocol::TcpSsl: {
|
|
auto host = std::make_unique<logos::plain::PlainTransportHost>(cfg);
|
|
if (!host->start()) {
|
|
qCritical() << "LogosTransportFactory: PlainTransportHost::start() failed";
|
|
return nullptr;
|
|
}
|
|
return host;
|
|
}
|
|
case LogosProtocol::LocalSocket:
|
|
default:
|
|
return std::make_unique<RemoteTransportHost>(registryUrl);
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<LogosTransportHost> createHost(const QString& registryUrl)
|
|
{
|
|
return createHost(LogosTransportConfigGlobal::getDefault(), registryUrl);
|
|
}
|
|
|
|
// Same resolution rule as createHost — see the comment block above.
|
|
std::unique_ptr<LogosTransportConnection>
|
|
createConnection(const LogosTransportConfig& cfg, const QString& registryUrl)
|
|
{
|
|
if (LogosModeConfig::isLocal()) {
|
|
return std::make_unique<LocalTransportConnection>();
|
|
}
|
|
if (LogosModeConfig::isMock()) {
|
|
return std::make_unique<MockTransportConnection>();
|
|
}
|
|
switch (cfg.protocol) {
|
|
case LogosProtocol::Tcp:
|
|
case LogosProtocol::TcpSsl:
|
|
return std::make_unique<logos::plain::PlainTransportConnection>(cfg);
|
|
case LogosProtocol::LocalSocket:
|
|
default:
|
|
return std::make_unique<RemoteTransportConnection>(registryUrl);
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<LogosTransportConnection> createConnection(const QString& registryUrl)
|
|
{
|
|
return createConnection(LogosTransportConfigGlobal::getDefault(), registryUrl);
|
|
}
|
|
|
|
// Same resolution rule as createConnection, answering "does the connection this
|
|
// cfg resolves to have to live on a thread with a Qt event loop?".
|
|
// Local → LocalTransportConnection: invokes in-process QObjects owned by
|
|
// the module's main thread. → yes
|
|
// Mock → MockTransportConnection: no Qt objects, no sockets. → no
|
|
// LocalSocket→ RemoteTransportConnection: QRemoteObjectNode + QLocalSocket;
|
|
// acquire and reply delivery both need the owner's loop. → yes
|
|
// Tcp/TcpSsl → PlainTransportConnection: Qt-free by design. → no
|
|
bool needsQtEventLoop(const LogosTransportConfig& cfg)
|
|
{
|
|
if (LogosModeConfig::isLocal()) return true;
|
|
if (LogosModeConfig::isMock()) return false;
|
|
switch (cfg.protocol) {
|
|
case LogosProtocol::Tcp:
|
|
case LogosProtocol::TcpSsl:
|
|
return false;
|
|
case LogosProtocol::LocalSocket:
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
}
|