rt_cmd_client.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "rt_cmd_client.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QDateTime>
#include <QThread>
 
#include <iostream>
 
constexpr bool USENEW = true;
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace COMLIB;
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
RtCmdClient::RtCmdClient(QObject* parent)
: QTcpSocket(parent)
{
    QObject::connect(&m_commandManager, &CommandManager::triggered, this,
                     &RtCmdClient::sendCommandJSON);
}
 
//=============================================================================================================
 
QString RtCmdClient::sendCLICommand(const QString& p_sCommand)
{
    QString t_sCommand = QString("%1\n").arg(p_sCommand);
    QString p_sReply;
 
    if (this->state() == QAbstractSocket::ConnectedState) {
        this->write(t_sCommand.toUtf8().constData(), t_sCommand.size());
        this->waitForBytesWritten();
 
        //thats not the most elegant way
        this->waitForReadyRead(1000);
        QByteArray t_qByteArrayRaw;
        // TODO(cpieloth): We need a break condition e.g. last byte == \0 or \n
        // Large responses can be split to more than one packet which could be a problem on big network latencies.
        while (this->bytesAvailable() > 0 && this->canReadLine())
            t_qByteArrayRaw += this->readAll();
 
        p_sReply = QString(t_qByteArrayRaw);
    }
    return p_sReply;
}
 
//=============================================================================================================
 
void RtCmdClient::sendCommandJSON(const Command& p_command)
{
    const QString t_sCommand = QString("{\"commands\":{%1}}\n").arg(p_command.toStringReadySend());
 
    QString t_sReply;
 
    if (this->state() == QAbstractSocket::ConnectedState) {
        // Send request
        if constexpr (USENEW) {
            QByteArray block;
            QDataStream out(&block, QIODevice::WriteOnly);
            out.setVersion(QDataStream::Qt_5_1);
 
            out << static_cast<quint16>(0);
            out << t_sCommand;
            out.device()->seek(0);
            out << static_cast<quint16>(static_cast<unsigned long>(block.size()) - sizeof(quint16));
 
            this->write(block);
            this->waitForBytesWritten();
 
            // Receive response
            QDataStream in(this);
            in.setVersion(QDataStream::Qt_5_1);
 
            quint16 blockSize = 0;
 
            bool respComplete = false;
 
            do {
                this->waitForReadyRead(100);
 
                if (blockSize == 0) {
                    if (this->bytesAvailable() >= static_cast<int>(sizeof(quint16)))
                        in >> blockSize;
                } else if (this->bytesAvailable() >= blockSize) {
                    in >> t_sReply;
                    respComplete = true;
                }
            } while (!respComplete && blockSize < 65000); //Sanity Check -> allowed maximal blocksize is 65.000
        } else {
            this->write(t_sCommand.toUtf8().constData(), t_sCommand.size());
            this->waitForBytesWritten();
 
            // Receive response
            bool respComplete = false;
            QByteArray t_qByteArrayRaw;
            do {
                if (this->waitForReadyRead(100)) {
                    t_qByteArrayRaw += this->readAll();
                    // We need a break condition,
                    // because we do not have a stop character and do not know how many bytes to receive.
                    respComplete = t_qByteArrayRaw.count('{') == t_qByteArrayRaw.count('}');
                }
                qDebug() << "Response: " << t_qByteArrayRaw.size() << " bytes";
            } while (!respComplete);
            t_sReply = QString(t_qByteArrayRaw);
        }
    } else {
        qWarning() << "Request was not send, because client is not connected!";
    }
 
    m_qMutex.lock();
    m_sAvailableData = t_sReply;
    m_qMutex.unlock();
 
    emit response(t_sReply);
}
 
//=============================================================================================================
 
qint32 RtCmdClient::requestBufsize()
{
    //Send
    m_commandManager["getbufsize"].send();
 
    //Receive
    m_qMutex.lock();
    QByteArray t_sJsonCommands = m_sAvailableData.toUtf8();
    m_qMutex.unlock();
 
    //Parse
    QJsonParseError error;
    QJsonDocument t_jsonDocumentOrigin = QJsonDocument::fromJson(t_sJsonCommands, &error);
 
    if (error.error == QJsonParseError::NoError) {
        //        qDebug() << t_jsonDocumentOrigin;//"Received Commands" << m_commandManager.commandMap().keys();
 
        //Switch to command object
        if (t_jsonDocumentOrigin.isObject() && t_jsonDocumentOrigin.object().value(QString("bufsize")) != QJsonValue::Undefined) {
            qint32 size = (qint32)t_jsonDocumentOrigin.object().value(QString("bufsize")).toDouble();
            return size;
        }
    }
 
    qCritical() << "Unable to parse JSON response: " << error.errorString();
    return -1;
}
 
//=============================================================================================================
 
void RtCmdClient::requestCommands()
{
    //No commands are present -> thats why help has to be send using a self created command
    const QString help("help");
    const QString description("");
    const Command cmdHelp(help, description);
    this->sendCommandJSON(cmdHelp);
 
    //Clear Commands
    m_commandManager.clear();
 
    //Receive
    m_qMutex.lock();
    QByteArray t_sJsonCommands = m_sAvailableData.toUtf8();
    m_qMutex.unlock();
 
    //Parse
    QJsonParseError error;
    QJsonDocument t_jsonDocumentOrigin = QJsonDocument::fromJson(
        t_sJsonCommands, &error);
 
    if (error.error == QJsonParseError::NoError)
        m_commandManager.insert(t_jsonDocumentOrigin);
    else
        qCritical() << "Unable to parse JSON response: " << error.errorString();
}
 
//=============================================================================================================
 
qint32 RtCmdClient::requestConnectors(QMap<qint32, QString>& p_qMapConnectors)
{
    //Send
    m_commandManager["conlist"].send();
 
    //Receive
    m_qMutex.lock();
    QByteArray t_sJsonConnectors = m_sAvailableData.toUtf8();
    m_qMutex.unlock();
 
    //Parse
    QJsonParseError error;
    QJsonDocument t_jsonDocumentOrigin = QJsonDocument::fromJson(
        t_sJsonConnectors, &error);
 
    QJsonObject t_jsonObjectConnectors;
 
    //Switch to command object
    if (t_jsonDocumentOrigin.isObject() && t_jsonDocumentOrigin.object().value(QString("connectors")) != QJsonValue::Undefined)
        t_jsonObjectConnectors = t_jsonDocumentOrigin.object().value(QString("connectors")).toObject();
 
    //inits
    qint32 p_iActiveId = -1;
    p_qMapConnectors.clear();
 
    //insert connectors
    QJsonObject::Iterator it;
    for (it = t_jsonObjectConnectors.begin(); it != t_jsonObjectConnectors.end(); ++it) {
        QString t_qConnectorName = it.key();
 
        qint32 id = it.value().toObject().value(QString("id")).toDouble();
 
        if (!p_qMapConnectors.contains(id))
            p_qMapConnectors.insert(id, t_qConnectorName);
        else
            qWarning("Warning: CommandMap contains command %s already. Insertion skipped.\n", it.key().toUtf8().constData());
 
        //if connector is active indicate it
        if (it.value().toObject().value(QString("active")).toBool())
            p_iActiveId = id;
    }
 
    return p_iActiveId;
}

 
//void RtCmdClient::requestMeasInfo(qint32 p_id)
//{
//    QString t_sCommand = QString("measinfo %1").arg(p_id);
//    this->sendCommand(t_sCommand);
//}

 
//void RtCmdClient::requestMeasInfo(const QString &p_Alias)
//{
//    QString t_sCommand = QString("measinfo %1").arg(p_Alias);
//    this->sendCommand(t_sCommand);
//}

 
//void RtCmdClient::requestMeas(qint32 p_id)
//{
//    QString t_sCommand = QString("start %1").arg(p_id);
//    this->sendCommand(t_sCommand);
//}

 
//void RtCmdClient::requestMeas(QString p_Alias)
//{
//    QString t_sCommand = QString("start %1").arg(p_Alias);
//    this->sendCommand(t_sCommand);
//}

 
//void RtCmdClient::stopAll()
//{
//    QString t_sCommand = QString("stop-all");
//    this->sendCommand(t_sCommand);
//}
 
//=============================================================================================================
 
bool RtCmdClient::waitForDataAvailable(qint32 msecs) const
{
    if (m_sAvailableData.size() > 0)
        return true;
 
    qint64 t_msecsStart = QDateTime::currentMSecsSinceEpoch();
 
    while (msecs == -1 || (qint64)msecs < QDateTime::currentMSecsSinceEpoch() - t_msecsStart) {
        QThread::msleep(5);
        if (m_sAvailableData.size() > 0)
            return true;
    }
    return false;
}
 
//=============================================================================================================
 
Command& RtCmdClient::operator[](const QString& key)
{
    return m_commandManager[key];
}
 
//=============================================================================================================
 
const Command RtCmdClient::operator[](const QString& key) const
{
    return m_commandManager[key];
}