@dusted/anqst 1.7.1 → 1.7.3

package/AnQstWebBase/src/AnQstHostBridgeFacade.cpp

@@ -0,0 +1,345 @@
+#include "AnQstHostBridgeFacade.h"
+
+#include <QEventLoop>
+#include <QTimer>
+
+namespace ANQST_WEBBASE_NAMESPACE {
+
+AnQstHostBridgeFacade::AnQstHostBridgeFacade(QObject* parent)
+    : QObject(parent)
+    , m_dispatchEnabled(false)
+    , m_slotRequestCounter(0)
+    , m_slotInvocationTimeoutMs(1000) {
+    connect(this, &AnQstHostBridgeFacade::slotInvocationResolved, this, [this](const QString&) {
+        // no-op connection so tests can wait for this signal deterministically.
+    });
+}
+
+void AnQstHostBridgeFacade::setCallHandler(const CallHandler& handler) {
+    m_callHandler = handler;
+}
+
+void AnQstHostBridgeFacade::setEmitterHandler(const EmitterHandler& handler) {
+    m_emitterHandler = handler;
+}
+
+void AnQstHostBridgeFacade::setInputHandler(const InputHandler& handler) {
+    m_inputHandler = handler;
+}
+
+void AnQstHostBridgeFacade::setOutputValue(const QString& service, const QString& member, const QVariant& value) {
+    const QString key = makeSlotKey(service, member);
+    m_outputValues.insert(key, value);
+    if (m_dispatchEnabled) {
+        emit bridgeOutputUpdated(service, member, value);
+    }
+}
+
+bool AnQstHostBridgeFacade::invokeSlot(const QString& service, const QString& member, const QVariantList& args, QVariant* result, QString* error) {
+    const QString key = makeSlotKey(service, member);
+    const QString requestId = QStringLiteral("slot-%1").arg(++m_slotRequestCounter);
+    m_slotInvocationResponses.insert(requestId, SlotInvocationResponse{});
+
+    PendingSlotInvocation pending{requestId, service, member, args};
+    if (m_dispatchEnabled && m_registeredSlots.value(key, false)) {
+        emit bridgeSlotInvocationRequested(requestId, service, member, args);
+    } else {
+        auto& queue = m_queuedSlotInvocations[key];
+        if (queue.size() >= kMaxQueuedSlotInvocations) {
+            emitQueuedSlotOverflowError(key);
+            m_slotInvocationResponses.remove(requestId);
+            if (error != nullptr) {
+                *error = QStringLiteral("slot queue overflow");
+            }
+            return false;
+        }
+        queue.enqueue(pending);
+    }
+
+    SlotInvocationResponse& response = m_slotInvocationResponses[requestId];
+    QEventLoop loop;
+    QTimer timeout;
+    timeout.setSingleShot(true);
+
+    connect(this, &AnQstHostBridgeFacade::slotInvocationResolved, &loop, [&](const QString& resolvedRequestId) {
+        if (resolvedRequestId == requestId) {
+            loop.quit();
+        }
+    });
+    connect(&timeout, &QTimer::timeout, &loop, &QEventLoop::quit);
+
+    timeout.start(m_slotInvocationTimeoutMs);
+    while (!response.done && timeout.isActive()) {
+        loop.exec();
+    }
+
+    if (!response.done) {
+        const bool slotRegistered = m_registeredSlots.value(key, false);
+        emitHostError(
+            slotRegistered ? QStringLiteral("BridgeTimeoutError") : QStringLiteral("HandlerNotRegisteredError"),
+            QStringLiteral("runtime"),
+            QStringLiteral("error"),
+            true,
+            slotRegistered
+                ? QStringLiteral("Slot invocation timed out while waiting for a frontend reply.")
+                : QStringLiteral("Slot invocation timed out before the frontend registered the slot handler."),
+            {
+                {QStringLiteral("service"), service},
+                {QStringLiteral("member"), member},
+                {QStringLiteral("requestId"), requestId},
+                {QStringLiteral("timeoutMs"), m_slotInvocationTimeoutMs},
+                {QStringLiteral("slotRegistered"), slotRegistered},
+                {QStringLiteral("reason"), slotRegistered ? QStringLiteral("reply_timeout") : QStringLiteral("registration_timeout")},
+            });
+        m_slotInvocationResponses.remove(requestId);
+        if (error != nullptr) {
+            *error = QStringLiteral("slot invocation timeout");
+        }
+        return false;
+    }
+
+    if (result != nullptr) {
+        *result = response.payload;
+    }
+    if (error != nullptr) {
+        *error = response.error;
+    }
+    const bool ok = response.ok;
+    m_slotInvocationResponses.remove(requestId);
+    return ok;
+}
+
+void AnQstHostBridgeFacade::setSlotInvocationTimeoutMs(int timeoutMs) {
+    if (timeoutMs <= 0) {
+        emitHostError(
+            QStringLiteral("HOST_MAPPING_PAYLOAD_INVALID"),
+            QStringLiteral("mapping"),
+            QStringLiteral("warn"),
+            true,
+            QStringLiteral("Slot invocation timeout must be positive."),
+            {{QStringLiteral("providedTimeoutMs"), timeoutMs}});
+        return;
+    }
+    m_slotInvocationTimeoutMs = timeoutMs;
+}
+
+int AnQstHostBridgeFacade::slotInvocationTimeoutMs() const {
+    return m_slotInvocationTimeoutMs;
+}
+
+void AnQstHostBridgeFacade::setDispatchEnabled(bool enabled) {
+    const bool changed = (m_dispatchEnabled != enabled);
+    m_dispatchEnabled = enabled;
+    if (!m_dispatchEnabled) {
+        m_registeredSlots.clear();
+    }
+    if (m_dispatchEnabled && changed) {
+        emitOutputSnapshot();
+        const auto registeredSlots = m_registeredSlots.keys();
+        for (const QString& slotKey : registeredSlots) {
+            dispatchQueuedSlotInvocations(slotKey);
+        }
+    }
+}
+
+bool AnQstHostBridgeFacade::dispatchEnabled() const {
+    return m_dispatchEnabled;
+}
+
+void AnQstHostBridgeFacade::registerSlot(const QString& service, const QString& member) {
+    const QString key = makeSlotKey(service, member);
+    m_registeredSlots.insert(key, true);
+    if (m_dispatchEnabled) {
+        dispatchQueuedSlotInvocations(key);
+    }
+}
+
+QVariant AnQstHostBridgeFacade::call(const QString& service, const QString& member, const QVariantList& args) {
+    if (!m_callHandler) {
+        emitHostError(
+            QStringLiteral("HOST_BRIDGE_SETUP_FAILED"),
+            QStringLiteral("bridge"),
+            QStringLiteral("error"),
+            false,
+            QStringLiteral("No Call handler has been configured."),
+            {
+                {QStringLiteral("service"), service},
+                {QStringLiteral("member"), member},
+            });
+        return QVariant();
+    }
+
+    try {
+        return m_callHandler(service, member, args);
+    } catch (...) {
+        emitHostError(
+            QStringLiteral("HOST_MAPPING_PAYLOAD_INVALID"),
+            QStringLiteral("mapping"),
+            QStringLiteral("error"),
+            true,
+            QStringLiteral("Call handler threw while processing payload."),
+            {
+                {QStringLiteral("service"), service},
+                {QStringLiteral("member"), member},
+            });
+        return QVariant();
+    }
+}
+
+void AnQstHostBridgeFacade::emitMessage(const QString& service, const QString& member, const QVariantList& args) {
+    if (!m_emitterHandler) {
+        return;
+    }
+
+    try {
+        m_emitterHandler(service, member, args);
+    } catch (const std::exception& ex) {
+        emitHostError(
+            QStringLiteral("EmitterHandlerError"),
+            QStringLiteral("bridge"),
+            QStringLiteral("error"),
+            true,
+            QStringLiteral("Emitter handler threw while processing payload."),
+            {
+                {QStringLiteral("service"), service},
+                {QStringLiteral("member"), member},
+                {QStringLiteral("detail"), QString::fromUtf8(ex.what())},
+            });
+    } catch (...) {
+        emitHostError(
+            QStringLiteral("EmitterHandlerError"),
+            QStringLiteral("bridge"),
+            QStringLiteral("error"),
+            true,
+            QStringLiteral("Emitter handler threw while processing payload."),
+            {
+                {QStringLiteral("service"), service},
+                {QStringLiteral("member"), member},
+            });
+    }
+}
+
+void AnQstHostBridgeFacade::setInput(const QString& service, const QString& member, const QVariant& value) {
+    if (!m_inputHandler) {
+        return;
+    }
+
+    try {
+        m_inputHandler(service, member, value);
+    } catch (const std::exception& ex) {
+        emitHostError(
+            QStringLiteral("InputHandlerError"),
+            QStringLiteral("bridge"),
+            QStringLiteral("error"),
+            true,
+            QStringLiteral("Input handler threw while processing payload."),
+            {
+                {QStringLiteral("service"), service},
+                {QStringLiteral("member"), member},
+                {QStringLiteral("detail"), QString::fromUtf8(ex.what())},
+            });
+    } catch (...) {
+        emitHostError(
+            QStringLiteral("InputHandlerError"),
+            QStringLiteral("bridge"),
+            QStringLiteral("error"),
+            true,
+            QStringLiteral("Input handler threw while processing payload."),
+            {
+                {QStringLiteral("service"), service},
+                {QStringLiteral("member"), member},
+            });
+    }
+}
+
+void AnQstHostBridgeFacade::resolveSlot(const QString& requestId, bool ok, const QVariant& payload, const QString& error) {
+    if (!m_slotInvocationResponses.contains(requestId)) {
+        return;
+    }
+    SlotInvocationResponse& response = m_slotInvocationResponses[requestId];
+    response.done = true;
+    response.ok = ok;
+    response.payload = payload;
+    response.error = error;
+    emit slotInvocationResolved(requestId);
+}
+
+void AnQstHostBridgeFacade::emitDrop(const QString& service, const QString& member, const QVariant& payload, double x, double y) {
+    if (m_dispatchEnabled) {
+        emit bridgeDropReceived(service, member, payload, x, y);
+    }
+}
+
+void AnQstHostBridgeFacade::emitHover(const QString& service, const QString& member, const QVariant& payload, double x, double y) {
+    if (m_dispatchEnabled) {
+        emit bridgeHoverUpdated(service, member, payload, x, y);
+    }
+}
+
+void AnQstHostBridgeFacade::emitHoverLeft(const QString& service, const QString& member) {
+    if (m_dispatchEnabled) {
+        emit bridgeHoverLeft(service, member);
+    }
+}
+
+void AnQstHostBridgeFacade::emitHostError(
+    const QString& code,
+    const QString& category,
+    const QString& severity,
+    bool recoverable,
+    const QString& message,
+    const QVariantMap& context) {
+    QVariantMap payload;
+    payload.insert(QStringLiteral("code"), code);
+    payload.insert(QStringLiteral("category"), category);
+    payload.insert(QStringLiteral("severity"), severity);
+    payload.insert(QStringLiteral("recoverable"), recoverable);
+    payload.insert(QStringLiteral("message"), message);
+    payload.insert(QStringLiteral("context"), context);
+    payload.insert(QStringLiteral("timestamp"), QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs));
+    emit bridgeHostError(payload);
+}
+
+QString AnQstHostBridgeFacade::makeSlotKey(const QString& service, const QString& member) const {
+    return service + QStringLiteral("::") + member;
+}
+
+void AnQstHostBridgeFacade::dispatchQueuedSlotInvocations(const QString& slotKey) {
+    if (!m_queuedSlotInvocations.contains(slotKey)) {
+        return;
+    }
+
+    auto& queue = m_queuedSlotInvocations[slotKey];
+    while (!queue.isEmpty()) {
+        const PendingSlotInvocation pending = queue.dequeue();
+        emit bridgeSlotInvocationRequested(pending.requestId, pending.service, pending.member, pending.args);
+    }
+}
+
+void AnQstHostBridgeFacade::emitQueuedSlotOverflowError(const QString& slotKey) {
+    emitHostError(
+        QStringLiteral("HOST_SLOT_QUEUE_OVERFLOW"),
+        QStringLiteral("runtime"),
+        QStringLiteral("error"),
+        true,
+        QStringLiteral("Slot queue exceeded capacity."),
+        {
+            {QStringLiteral("slot"), slotKey},
+            {QStringLiteral("maxQueueSize"), kMaxQueuedSlotInvocations},
+        });
+}
+
+void AnQstHostBridgeFacade::emitOutputSnapshot() {
+    for (auto it = m_outputValues.constBegin(); it != m_outputValues.constEnd(); ++it) {
+        const QString key = it.key();
+        const int splitIdx = key.indexOf(QStringLiteral("::"));
+        if (splitIdx <= 0) {
+            continue;
+        }
+        const QString service = key.left(splitIdx);
+        const QString member = key.mid(splitIdx + 2);
+        emit bridgeOutputUpdated(service, member, it.value());
+    }
+}
+
+} // namespace ANQST_WEBBASE_NAMESPACE

package/AnQstWebBase/src/AnQstHostBridgeFacade.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "AnQstWebBaseAbi.h"
+
+#include <QDateTime>
+#include <QHash>
+#include <QMap>
+#include <QObject>
+#include <QQueue>
+#include <QString>
+#include <QVariant>
+#include <QVariantList>
+#include <QVariantMap>
+#include <functional>
+
+namespace ANQST_WEBBASE_NAMESPACE {
+
+class AnQstHostBridgeFacade : public QObject {
+    Q_OBJECT
+
+public:
+    static constexpr int kMaxQueuedSlotInvocations = 1024;
+
+    using CallHandler = std::function<QVariant(const QString& service, const QString& member, const QVariantList& args)>;
+    using EmitterHandler = std::function<void(const QString& service, const QString& member, const QVariantList& args)>;
+    using InputHandler = std::function<void(const QString& service, const QString& member, const QVariant&)>;
+
+    explicit AnQstHostBridgeFacade(QObject* parent = nullptr);
+
+    void setCallHandler(const CallHandler& handler);
+    void setEmitterHandler(const EmitterHandler& handler);
+    void setInputHandler(const InputHandler& handler);
+    void setOutputValue(const QString& service, const QString& member, const QVariant& value);
+    bool invokeSlot(const QString& service, const QString& member, const QVariantList& args, QVariant* result = nullptr, QString* error = nullptr);
+    void setSlotInvocationTimeoutMs(int timeoutMs);
+    int slotInvocationTimeoutMs() const;
+
+    void setDispatchEnabled(bool enabled);
+    bool dispatchEnabled() const;
+    void emitOutputSnapshot();
+
+    void emitDrop(const QString& service, const QString& member, const QVariant& payload, double x, double y);
+    void emitHover(const QString& service, const QString& member, const QVariant& payload, double x, double y);
+    void emitHoverLeft(const QString& service, const QString& member);
+
+    void registerSlot(const QString& service, const QString& member);
+    QVariant call(const QString& service, const QString& member, const QVariantList& args);
+    void emitMessage(const QString& service, const QString& member, const QVariantList& args);
+    void setInput(const QString& service, const QString& member, const QVariant& value);
+    void resolveSlot(const QString& requestId, bool ok, const QVariant& payload, const QString& error);
+
+signals:
+    void bridgeOutputUpdated(const QString& service, const QString& member, const QVariant& value);
+    void bridgeSlotInvocationRequested(const QString& requestId, const QString& service, const QString& member, const QVariantList& args);
+    void bridgeHostError(const QVariantMap& errorPayload);
+    void slotInvocationResolved(const QString& requestId);
+    void bridgeDropReceived(const QString& service, const QString& member, const QVariant& payload, double x, double y);
+    void bridgeHoverUpdated(const QString& service, const QString& member, const QVariant& payload, double x, double y);
+    void bridgeHoverLeft(const QString& service, const QString& member);
+
+private:
+    struct PendingSlotInvocation {
+        QString requestId;
+        QString service;
+        QString member;
+        QVariantList args;
+    };
+
+    struct SlotInvocationResponse {
+        bool done{false};
+        bool ok{false};
+        QVariant payload;
+        QString error;
+    };
+
+    void emitHostError(
+        const QString& code,
+        const QString& category,
+        const QString& severity,
+        bool recoverable,
+        const QString& message,
+        const QVariantMap& context = QVariantMap());
+    QString makeSlotKey(const QString& service, const QString& member) const;
+    void dispatchQueuedSlotInvocations(const QString& slotKey);
+    void emitQueuedSlotOverflowError(const QString& slotKey);
+
+    bool m_dispatchEnabled;
+    quint64 m_slotRequestCounter;
+    CallHandler m_callHandler;
+    EmitterHandler m_emitterHandler;
+    InputHandler m_inputHandler;
+    QHash<QString, bool> m_registeredSlots;
+    QHash<QString, QQueue<PendingSlotInvocation>> m_queuedSlotInvocations;
+    QHash<QString, SlotInvocationResponse> m_slotInvocationResponses;
+    QHash<QString, QVariant> m_outputValues;
+    int m_slotInvocationTimeoutMs;
+};
+
+} // namespace ANQST_WEBBASE_NAMESPACE

package/AnQstWebBase/src/AnQstWebBaseAbi.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define ANQST_WEBBASE_ABI_HASH_STAMP "_da43ea0d526e8ac0a869ccc79976519d2566b40d8b97a12bddfa2aaaac5304f6"
+#define ANQST_WEBBASE_NAMESPACE anqstwebbase_da43ea0d526e8ac0a869ccc79976519d2566b40d8b97a12bddfa2aaaac5304f6

package/AnQstWebBase/src/AnQstWebBaseAbi.h.in

@@ -0,0 +1,4 @@
+#pragma once
+
+#define ANQST_WEBBASE_ABI_HASH_STAMP "@ANQST_WEBBASE_ABI_HASH_STAMP@"
+#define ANQST_WEBBASE_NAMESPACE anqstwebbase@ANQST_WEBBASE_ABI_HASH_STAMP@