You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
609 lines
17 KiB
609 lines
17 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Some code by AI // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <QCryptographicHash> |
|
#include <QDebug> |
|
#include <QJsonArray> |
|
#include <QJsonDocument> |
|
#include <QUuid> |
|
|
|
#include <algorithm> |
|
|
|
#include "maincore.h" |
|
#include "channel/channelapi.h" |
|
#include "device/deviceapi.h" |
|
#include "feature/feature.h" |
|
|
|
#include "mcpdatafeed.h" |
|
#include "mcperror.h" |
|
#include "mcpstreams.h" |
|
#include "mcptools.h" |
|
|
|
// --------------------------------------------------------------------------- |
|
// MCPEventStream |
|
// --------------------------------------------------------------------------- |
|
|
|
MCPEventStream::MCPEventStream(const QString& sessionId) : |
|
m_sessionId(sessionId), |
|
m_closed(false) |
|
{ |
|
m_age.start(); |
|
} |
|
|
|
qint64 MCPEventStream::ageMs() const |
|
{ |
|
return m_age.elapsed(); |
|
} |
|
|
|
void MCPEventStream::push(const QByteArray& event) |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
|
|
if (m_closed) { |
|
return; |
|
} |
|
|
|
m_events.enqueue(event); |
|
|
|
while (m_events.size() > m_maxQueued) { |
|
m_events.dequeue(); |
|
} |
|
|
|
m_wait.wakeAll(); |
|
} |
|
|
|
QByteArray MCPEventStream::waitForEvent(int timeoutMs) |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
|
|
if (m_events.isEmpty() && !m_closed) { |
|
m_wait.wait(&m_mutex, timeoutMs); |
|
} |
|
|
|
if (m_events.isEmpty()) { |
|
return QByteArray(); |
|
} |
|
|
|
return m_events.dequeue(); |
|
} |
|
|
|
void MCPEventStream::close() |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
m_closed = true; |
|
m_wait.wakeAll(); |
|
} |
|
|
|
bool MCPEventStream::isClosed() const |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
return m_closed; |
|
} |
|
|
|
// --------------------------------------------------------------------------- |
|
// MCPStreams |
|
// --------------------------------------------------------------------------- |
|
|
|
MCPStreams::MCPStreams() : |
|
m_notificationsSent(0) |
|
{ |
|
} |
|
|
|
MCPStreams::~MCPStreams() |
|
{ |
|
closeAll(); |
|
} |
|
|
|
QString MCPStreams::createSession() |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
QString id = QUuid::createUuid().toString(QUuid::WithoutBraces); |
|
m_sessions.insert(id, QDateTime::currentDateTimeUtc()); |
|
expireSessions(); |
|
return id; |
|
} |
|
|
|
bool MCPStreams::sessionExists(const QString& sessionId) |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
|
|
if (!m_sessions.contains(sessionId)) { |
|
return false; |
|
} |
|
|
|
m_sessions[sessionId] = QDateTime::currentDateTimeUtc(); |
|
return true; |
|
} |
|
|
|
// Clients are not obliged to end their session, and a bridge that reconnects starts a new one |
|
// every time, so idle sessions are dropped rather than kept for the life of the process. |
|
// Sessions with an open stream are never dropped. Call with the mutex held. |
|
void MCPStreams::expireSessions() |
|
{ |
|
QSet<QString> streaming; |
|
|
|
for (const StreamPtr& stream : m_streams) { |
|
streaming.insert(stream->getSessionId()); |
|
} |
|
|
|
QDateTime now = QDateTime::currentDateTimeUtc(); |
|
QList<QString> candidates; |
|
|
|
for (auto it = m_sessions.begin(); it != m_sessions.end(); ++it) |
|
{ |
|
if (!streaming.contains(it.key())) { |
|
candidates.append(it.key()); |
|
} |
|
} |
|
|
|
// Oldest first, so that trimming to the cap drops the least recently used |
|
std::sort(candidates.begin(), candidates.end(), [this](const QString& a, const QString& b) { |
|
return m_sessions[a] < m_sessions[b]; |
|
}); |
|
|
|
int droppable = candidates.size() - qMax(0, m_maxSessions - (int) streaming.size()); |
|
|
|
for (int i = 0; i < candidates.size(); i++) |
|
{ |
|
const QString& id = candidates[i]; |
|
bool tooOld = m_sessions[id].msecsTo(now) > m_sessionIdleMs; |
|
bool overCap = i < droppable; |
|
|
|
if (tooOld || overCap) |
|
{ |
|
m_sessions.remove(id); |
|
m_subscriptions.remove(id); |
|
} |
|
} |
|
} |
|
|
|
void MCPStreams::endSession(const QString& sessionId) |
|
{ |
|
QList<StreamPtr> toClose; |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
m_sessions.remove(sessionId); |
|
m_subscriptions.remove(sessionId); |
|
|
|
for (const StreamPtr& stream : m_streams) |
|
{ |
|
if (stream->getSessionId() == sessionId) { |
|
toClose.append(stream); |
|
} |
|
} |
|
} |
|
|
|
// Closing wakes the HTTP thread serving the stream, which then removes it. Holding a |
|
// shared pointer keeps each one alive until this call is done with it. |
|
for (const StreamPtr& stream : toClose) { |
|
stream->close(); |
|
} |
|
} |
|
|
|
QSet<QString> MCPStreams::subscribedUris() const |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
QSet<QString> uris; |
|
|
|
for (const QSet<QString>& perSession : m_subscriptions) { |
|
uris.unite(perSession); |
|
} |
|
|
|
return uris; |
|
} |
|
|
|
bool MCPStreams::subscribe(const QString& sessionId, const QString& uri) |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
QSet<QString>& uris = m_subscriptions[sessionId]; |
|
|
|
// Bounded: every subscription is polled for changes each second, and the anonymous |
|
// session's set has no DELETE to clear it |
|
if (!uris.contains(uri) && (uris.size() >= m_maxSubscriptions)) { |
|
return false; |
|
} |
|
|
|
uris.insert(uri); |
|
return true; |
|
} |
|
|
|
bool MCPStreams::unsubscribe(const QString& sessionId, const QString& uri) |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
|
|
if (!m_subscriptions.contains(sessionId)) { |
|
return false; |
|
} |
|
|
|
return m_subscriptions[sessionId].remove(uri); |
|
} |
|
|
|
QSet<QString> MCPStreams::subscriptions(const QString& sessionId) const |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
return m_subscriptions.value(sessionId); |
|
} |
|
|
|
MCPStreams::StreamPtr MCPStreams::open(const QString& sessionId, QString& error) |
|
{ |
|
QList<StreamPtr> superseded; |
|
QMutexLocker locker(&m_mutex); |
|
|
|
// A server message must reach a client on one stream only, so a session keeps a single |
|
// stream: opening another replaces the one before it. Clients that send no session id |
|
// already share the anonymous subscriptions and cannot be told apart, so they share one |
|
// stream on the same rule rather than each receiving every notification. |
|
for (int i = m_streams.size() - 1; i >= 0; i--) |
|
{ |
|
if (m_streams[i]->getSessionId() == sessionId) |
|
{ |
|
superseded.append(m_streams[i]); |
|
m_streams.removeAt(i); |
|
} |
|
} |
|
|
|
if (m_streams.size() >= m_maxStreams) |
|
{ |
|
locker.unlock(); |
|
|
|
for (const StreamPtr& stream : superseded) { |
|
stream->close(); |
|
} |
|
|
|
error = QString("Too many open event streams (%1)").arg(m_maxStreams); |
|
return StreamPtr(); |
|
} |
|
|
|
StreamPtr stream(new MCPEventStream(sessionId)); |
|
m_streams.append(stream); |
|
qDebug("MCPStreams::open: stream opened, %d open, %d superseded", (int) m_streams.size(), (int) superseded.size()); |
|
locker.unlock(); |
|
|
|
// Wakes the HTTP thread serving each replaced stream so that it finishes its response |
|
for (const StreamPtr& older : superseded) { |
|
older->close(); |
|
} |
|
|
|
return stream; |
|
} |
|
|
|
// The stream is only destroyed once every holder has released its shared pointer, so a |
|
// notification in flight on another thread cannot be left pointing at freed memory. |
|
void MCPStreams::close(const StreamPtr& stream) |
|
{ |
|
if (stream.isNull()) { |
|
return; |
|
} |
|
|
|
QMutexLocker locker(&m_mutex); |
|
m_streams.removeAll(stream); |
|
qDebug("MCPStreams::close: stream closed, %d open", (int) m_streams.size()); |
|
} |
|
|
|
void MCPStreams::closeAll() |
|
{ |
|
QList<StreamPtr> streams; |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
streams = m_streams; |
|
} |
|
|
|
// Only ask them to stop: the HTTP thread serving each stream removes it when it exits |
|
for (const StreamPtr& stream : streams) { |
|
stream->close(); |
|
} |
|
} |
|
|
|
QByteArray MCPStreams::resourceUpdatedEvent(const QString& uri) |
|
{ |
|
QJsonObject params; |
|
params["uri"] = uri; |
|
QJsonObject notification; |
|
notification["jsonrpc"] = "2.0"; |
|
notification["method"] = "notifications/resources/updated"; |
|
notification["params"] = params; |
|
return QJsonDocument(notification).toJson(QJsonDocument::Compact); |
|
} |
|
|
|
void MCPStreams::notifyResourceUpdated(const QString& uri) |
|
{ |
|
QList<StreamPtr> targets; |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
|
|
for (const StreamPtr& stream : m_streams) |
|
{ |
|
if (m_subscriptions.value(stream->getSessionId()).contains(uri)) { |
|
targets.append(stream); |
|
} |
|
} |
|
|
|
m_notificationsSent += targets.size(); |
|
} |
|
|
|
if (targets.isEmpty()) { |
|
return; |
|
} |
|
|
|
QByteArray event = resourceUpdatedEvent(uri); |
|
|
|
for (const StreamPtr& stream : targets) { |
|
stream->push(event); |
|
} |
|
} |
|
|
|
void MCPStreams::notifyResourcesMatching(const QString& prefix) |
|
{ |
|
QSet<QString> uris; |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
|
|
for (const StreamPtr& stream : m_streams) |
|
{ |
|
for (const QString& uri : m_subscriptions.value(stream->getSessionId())) |
|
{ |
|
if (uri.startsWith(prefix)) { |
|
uris.insert(uri); |
|
} |
|
} |
|
} |
|
} |
|
|
|
for (const QString& uri : uris) { |
|
notifyResourceUpdated(uri); |
|
} |
|
} |
|
|
|
int MCPStreams::streamCount() const |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
return (int) m_streams.size(); |
|
} |
|
|
|
qint64 MCPStreams::getNotificationsSent() const |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
return m_notificationsSent; |
|
} |
|
|
|
QJsonObject MCPStreams::status() const |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
QJsonObject result; |
|
result["openStreams"] = (int) m_streams.size(); |
|
result["maxStreams"] = m_maxStreams; |
|
result["sessions"] = (int) m_sessions.size(); |
|
result["notificationsSent"] = (double) m_notificationsSent; |
|
QJsonArray subscribed; |
|
|
|
for (auto it = m_subscriptions.begin(); it != m_subscriptions.end(); ++it) |
|
{ |
|
for (const QString& uri : it.value()) |
|
{ |
|
QJsonObject entry; |
|
entry["session"] = it.key().isEmpty() ? QString("(anonymous)") : it.key(); |
|
entry["uri"] = uri; |
|
subscribed.append(entry); |
|
} |
|
} |
|
|
|
result["subscriptions"] = subscribed; |
|
return result; |
|
} |
|
|
|
// --------------------------------------------------------------------------- |
|
// MCPNotifier |
|
// --------------------------------------------------------------------------- |
|
|
|
MCPNotifier::MCPNotifier(MCPStreams *streams, MCPDataFeed *dataFeed, MCPTools *tools, QObject *parent) : |
|
QObject(parent), |
|
m_streams(streams), |
|
m_tools(tools), |
|
m_pendingDeviceSets(false) |
|
{ |
|
MainCore *mainCore = MainCore::instance(); |
|
connect(mainCore, &MainCore::deviceSetAdded, this, &MCPNotifier::onDeviceSetAdded); |
|
connect(mainCore, &MainCore::deviceStateChanged, this, &MCPNotifier::onDeviceStateChanged); |
|
connect(mainCore, &MainCore::deviceSetRemoved, this, &MCPNotifier::onDeviceSetRemoved); |
|
connect(mainCore, &MainCore::deviceChanged, this, &MCPNotifier::onDeviceChanged); |
|
connect(mainCore, &MainCore::channelAdded, this, &MCPNotifier::onChannelAdded); |
|
connect(mainCore, &MainCore::channelRemoved, this, &MCPNotifier::onChannelRemoved); |
|
connect(mainCore, &MainCore::featureAdded, this, &MCPNotifier::onFeatureAdded); |
|
connect(mainCore, &MainCore::featureRemoved, this, &MCPNotifier::onFeatureRemoved); |
|
|
|
if (dataFeed) |
|
{ |
|
connect(dataFeed, &MCPDataFeed::packetsChanged, this, &MCPNotifier::onPacketsChanged); |
|
connect(dataFeed, &MCPDataFeed::mapItemsChanged, this, &MCPNotifier::onMapItemsChanged); |
|
} |
|
|
|
// Changes are collected and sent at most this often, so that a busy decoder does not |
|
// turn every decoded packet into a notification |
|
m_timer.setInterval(m_coalesceMs); |
|
connect(&m_timer, &QTimer::timeout, this, &MCPNotifier::flush); |
|
m_timer.start(); |
|
} |
|
|
|
void MCPNotifier::markChanged(const QString& uri) |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
m_pending.insert(uri); |
|
} |
|
|
|
void MCPNotifier::markStructuralChange() |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
m_pending.insert("sdrangel://instance"); |
|
m_pendingDeviceSets = true; |
|
} |
|
|
|
void MCPNotifier::onDeviceSetAdded(int index, DeviceAPI *device) |
|
{ |
|
(void) index; |
|
(void) device; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onDeviceSetRemoved(int index) |
|
{ |
|
(void) index; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onDeviceStateChanged(int index, DeviceAPI *device) |
|
{ |
|
(void) index; |
|
(void) device; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onDeviceChanged(int index) |
|
{ |
|
(void) index; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onChannelAdded(int deviceSetIndex, ChannelAPI *channel) |
|
{ |
|
(void) deviceSetIndex; |
|
(void) channel; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onChannelRemoved(int deviceSetIndex, ChannelAPI *channel) |
|
{ |
|
(void) deviceSetIndex; |
|
(void) channel; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onFeatureAdded(int featureSetIndex, Feature *feature) |
|
{ |
|
(void) featureSetIndex; |
|
(void) feature; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onFeatureRemoved(int featureSetIndex, Feature *feature) |
|
{ |
|
(void) featureSetIndex; |
|
(void) feature; |
|
markStructuralChange(); |
|
} |
|
|
|
void MCPNotifier::onPacketsChanged() |
|
{ |
|
markChanged("sdrangel://packets"); |
|
} |
|
|
|
void MCPNotifier::onMapItemsChanged() |
|
{ |
|
markChanged("sdrangel://map/items"); |
|
} |
|
|
|
// MainCore announces device sets, channels and features appearing and disappearing, but nothing |
|
// at all when a setting changes, so a title or a frequency edited in the GUI or over the API would |
|
// leave a subscriber holding a stale resource. The rendered content is compared instead, for the |
|
// subscribed resources only, so a session that asked for nothing costs nothing |
|
void MCPNotifier::pollForContentChanges() |
|
{ |
|
if (!m_tools) { |
|
return; |
|
} |
|
|
|
QSet<QString> uris = m_streams->subscribedUris(); |
|
|
|
for (QMap<QString, QByteArray>::iterator digest = m_digests.begin(); digest != m_digests.end(); ) |
|
{ |
|
if (uris.contains(digest.key())) { |
|
++digest; |
|
} else { |
|
digest = m_digests.erase(digest); |
|
} |
|
} |
|
|
|
for (const QString& uri : uris) |
|
{ |
|
QJsonObject content; |
|
int index = -1; |
|
|
|
if (uri.startsWith("sdrangel://deviceset/")) |
|
{ |
|
bool ok = false; |
|
index = uri.mid(QString("sdrangel://deviceset/").size()).toInt(&ok); |
|
|
|
// A device set that is not there is not read: the read would only throw, once a |
|
// second for as long as the subscription lasts |
|
if (!ok || (index < 0) || (index >= m_tools->deviceSetCount())) { |
|
continue; |
|
} |
|
} |
|
else if (uri != "sdrangel://instance") |
|
{ |
|
continue; // the others have their own signals |
|
} |
|
|
|
// Reading a resource throws when it is not there any more, and this runs in a timer slot, |
|
// where an exception would escape into the event loop and take the application down with |
|
// it. A device set that has just gone is reported by the structural signal anyway |
|
try { |
|
content = (index < 0) ? m_tools->getInstanceSummary() : m_tools->getDeviceSet(index); |
|
} catch (const MCPToolError&) { |
|
continue; |
|
} catch (const std::exception&) { |
|
continue; |
|
} |
|
|
|
QByteArray hash = QCryptographicHash::hash( |
|
QJsonDocument(content).toJson(QJsonDocument::Compact), QCryptographicHash::Md5); |
|
|
|
if (m_digests.contains(uri) && (m_digests[uri] != hash)) { |
|
markChanged(uri); |
|
} |
|
|
|
m_digests[uri] = hash; |
|
} |
|
} |
|
|
|
void MCPNotifier::flush() |
|
{ |
|
pollForContentChanges(); |
|
|
|
QSet<QString> pending; |
|
bool deviceSets; |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
|
|
if (m_pending.isEmpty() && !m_pendingDeviceSets) { |
|
return; |
|
} |
|
|
|
pending = m_pending; |
|
deviceSets = m_pendingDeviceSets; |
|
m_pending.clear(); |
|
m_pendingDeviceSets = false; |
|
} |
|
|
|
for (const QString& uri : pending) { |
|
m_streams->notifyResourceUpdated(uri); |
|
} |
|
|
|
if (deviceSets) { |
|
m_streams->notifyResourcesMatching("sdrangel://deviceset/"); |
|
} |
|
}
|
|
|