From 0d5af640ed78aa907af9498d17b96d6dbe9ed2f2 Mon Sep 17 00:00:00 2001
From: Alexander <aleksandr.martynov@demlabs.net>
Date: Thu, 17 Oct 2019 12:48:30 -0400
Subject: [PATCH] Features 2581
---
DapRPCProtocol/DapRpcServiceRequest.h | 31 +++++++++-
DapRPCProtocol/DapRpcSocket.h | 84 ++++++++++++++++++++++++++-
DapRPCProtocol/DapRpcTCPServer.h | 36 +++++++++++-
3 files changed, 147 insertions(+), 4 deletions(-)
diff --git a/DapRPCProtocol/DapRpcServiceRequest.h b/DapRPCProtocol/DapRpcServiceRequest.h
index aa689f8..0949ff6 100644
--- a/DapRPCProtocol/DapRpcServiceRequest.h
+++ b/DapRPCProtocol/DapRpcServiceRequest.h
@@ -8,24 +8,53 @@
#include "DapRpcMessage.h"
class DapRpcSocket;
+/**
+ * @brief The DapRpcServiceRequest class
+ * Class provides to operate with request message by socket interface
+ * @see DapRpcSocket
+ */
class DapRpcServiceRequest
{
+ /// Request message
DapRpcMessage m_request;
+ /// RPC socket
QPointer<DapRpcSocket> m_socket;
public:
+ /// Standard constructor
DapRpcServiceRequest();
+ /// Copy constructor
DapRpcServiceRequest(const DapRpcServiceRequest &aDapRpcServiceRequest);
+ /// Overloaded constructor
+ /// @param aRequest Request message
+ /// @param apSocket Pointer to RPC socket
DapRpcServiceRequest(const DapRpcMessage &aRequest, DapRpcSocket *apSocket);
+ /// Overloaded assignment operator
+ /// @param aDapRpcServiceRequest Other DapRpcServiceRequest object
+ /// @return Reference to this object
DapRpcServiceRequest &operator=(const DapRpcServiceRequest &aDapRpcServiceRequest);
+ /// Standard destructor
~DapRpcServiceRequest();
+ /// Validation of request message
+ /// @return If request message is valid or socket is not null return true.
+ /// Otherwise return false
bool isValid() const;
+ /// Get request message
+ /// @return Request message
DapRpcMessage request() const;
+ /// Get current socket
+ /// @return Socket
DapRpcSocket *socket() const;
- bool respond(const DapRpcMessage &aResponse);
+ /// Create response to following respont by socket
+ /// @param aReturnValue Return value from service
+ /// @return False if socket is closed
bool respond(QVariant aReturnValue);
+ /// Send response to socket
+ /// @param aResponse Response message
+ /// @return False if socket is closed
+ bool respond(const DapRpcMessage &aResponse);
};
#endif // DapRPCSERVICEREQUEST_H
diff --git a/DapRPCProtocol/DapRpcSocket.h b/DapRPCProtocol/DapRpcSocket.h
index 9a2836d..b781035 100644
--- a/DapRPCProtocol/DapRpcSocket.h
+++ b/DapRPCProtocol/DapRpcSocket.h
@@ -15,54 +15,136 @@
#define DEFAULT_MSECS_REQUEST_TIMEOUT (30000)
+/**
+ * @brief The DapRpcSocket class
+ * Realization socket interface:
+ * - Store information about device and data
+ * - Sending/receiving messages
+ * - Control sending request by timeout
+ */
class DapRpcSocket : public QObject
{
Q_OBJECT
Q_DISABLE_COPY(DapRpcSocket)
+ /// Pointer to IO device
QPointer<QIODevice> m_pDevice;
+ /// Buffer
QByteArray m_aBuffer;
+ /// Storage to replies by id
QHash<int, QPointer<DapRpcServiceReply>> m_replies;
+ /// Default request timeout
int m_defaultRequestTimeout;
protected:
+ /// TODO: not implement
+ /// @param asMessage Request message
virtual void processRequestMessage(const DapRpcMessage &asMessage);
public:
+ /// Standard constructor
explicit DapRpcSocket(QObject *apParent = nullptr);
+ /// Overloaded constructor
+ /// @param apDevice Device whick provides both a common implementation and
+ /// an abstract interface for devices that support reading and writing of blocks of data
explicit DapRpcSocket(QIODevice *apDevice, QObject *apParent = nullptr);
+ /// Virtual destructor
virtual ~DapRpcSocket();
+ /// Validation initialization and open device
+ /// @return True if device initilized and opened. Otherwise return false
virtual bool isValid() const;
+ /// Set default request timeout
+ /// @param aiMsecs Miliseconds
void setDefaultRequestTimeout(int aiMsecs);
+ /// Get default request timeout
+ /// @return Default request timeout
int getDefaultRequestTimeout() const;
-
+ /// Set IO Device
+ /// @param Pointer to IO device
void setIODevice(QIODevice *pDevice);
signals:
+ /// The signal emitted when message was received
+ /// @param asMessage Request message
void messageReceived(const DapRpcMessage &asMessage);
private slots:
+ /// Read data from device and prepare reply
virtual void processIncomingData();
+ /// Find end of Json document
+ /// @param aJsonData Json data where need to find end
+ /// @return Index of end json document. If file empty return -1
int findJsonDocumentEnd(const QByteArray &aJsonData);
+ /// Write data from message to device
+ /// @param asMessage Request message
void writeData(const DapRpcMessage &asMessage);
public slots:
+ /// Notify to new request message and try to send to device
+ /// @param asMessage Request message
virtual void notify(const DapRpcMessage &asMessage);
+ /// Send message with delay for sending message
+ /// @param asMessage Request message
+ /// @param aMsecs Delay request timeout. If not pass parameter uses default value
+ /// @return Response from reply
virtual DapRpcMessage sendMessageBlocking(const DapRpcMessage &asMessage, int aMsecs = DEFAULT_MSECS_REQUEST_TIMEOUT);
+ /// Send request message to device
+ /// @param asMessage Request message
+ /// @return Pointer of service reply
virtual DapRpcServiceReply *sendMessage(const DapRpcMessage &asMessage);
+ /// Invoke remote method and create response to send to IO device with delay
+ /// @param asMethod Method's name
+ /// @param aMsecs Delay time for send
+ /// @param arg1 First argument
+ /// @param arg2 Second argument
+ /// @param arg3 Third argument
+ /// @param arg4 Fourth argument
+ /// @param arg5 Fifth argument
+ /// @param arg6 Six argument
+ /// @param arg7 Seven argument
+ /// @param arg8 Eight argument
+ /// @param arg9 Nine argument
+ /// @param arg10 Ten argument
+ /// @return Response from reply
DapRpcMessage invokeRemoteMethodBlocking(const QString &asMethod, int aMsecs, const QVariant &arg1 = QVariant(),
const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
const QVariant &arg10 = QVariant());
+ /// Invoke remote method and create response to send to IO device with default delay time
+ /// @param asMethod Method's name
+ /// @param arg1 First argument
+ /// @param arg2 Second argument
+ /// @param arg3 Third argument
+ /// @param arg4 Fourth argument
+ /// @param arg5 Fifth argument
+ /// @param arg6 Six argument
+ /// @param arg7 Seven argument
+ /// @param arg8 Eight argument
+ /// @param arg9 Nine argument
+ /// @param arg10 Ten argument
+ /// @return Response from reply
DapRpcMessage invokeRemoteMethodBlocking(const QString &asMethod, const QVariant &arg1 = QVariant(),
const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
const QVariant &arg10 = QVariant());
+ /// Invoke remote method and create response to send to IO device
+ /// @param asMethod Method's name
+ /// @param arg1 First argument
+ /// @param arg2 Second argument
+ /// @param arg3 Third argument
+ /// @param arg4 Fourth argument
+ /// @param arg5 Fifth argument
+ /// @param arg6 Six argument
+ /// @param arg7 Seven argument
+ /// @param arg8 Eight argument
+ /// @param arg9 Nine argument
+ /// @param arg10 Ten argument
+ /// @return Pointer to service reply
DapRpcServiceReply *invokeRemoteMethod(const QString &asMethod, const QVariant &arg1 = QVariant(),
const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
diff --git a/DapRPCProtocol/DapRpcTCPServer.h b/DapRPCProtocol/DapRpcTCPServer.h
index 00b2e47..d48b304 100644
--- a/DapRPCProtocol/DapRpcTCPServer.h
+++ b/DapRPCProtocol/DapRpcTCPServer.h
@@ -8,36 +8,68 @@
#include "DapRpcSocket.h"
#include "DapRpcAbstractServer.h"
+/**
+ * @brief The DapRpcTCPServer class
+ * TCP server class realize interface DapRpcAbstractServer
+ * @see DapRpcAbstractServer
+ * @see QTcpServer
+ */
class DapRpcTCPServer : public QTcpServer, public DapRpcAbstractServer
{
Q_OBJECT
Q_DISABLE_COPY(DapRpcTCPServer)
-
+ /// Lookup's tcp sockets witj Rpc sockets
QHash<QTcpSocket*, DapRpcSocket*> m_socketLookup;
protected:
+ /// This virtual function is called by QTcpServer when a new connection is available
+ /// @param aSocketDescriptor The socketDescriptor argument is the native socket
+ /// descriptor for the accepted connection
virtual void incomingConnection(qintptr aSocketDescriptor);
public:
+ /// Standard constructor
explicit DapRpcTCPServer(QObject *apParent = nullptr);
+ /// Virtual destructor
virtual ~DapRpcTCPServer();
+ /// Tells the server to listen for incoming connections on address
+ /// @param asAddress Address
+ /// @param aPort Port. If port is 0, a port is chosen automatically
+ /// @param If address is QHostAddress::Any, the server will listen on all network interfaces
+ /// @return Returns true on success; otherwise returns false.
+ /// @see isListening()
virtual bool listen(const QString &asAddress = QString(), quint16 aPort = 0);
-
+ /// Add new service
+ /// @param apService New service
+ /// @return If service add successfully return true. Otherwise return false
bool addService(DapRpcService *apService);
+ /// Remove service
+ /// @param apService Service for removing
+ /// @return If service add successfully return true. Otherwise return false
bool removeService(DapRpcService *apService);
signals:
+ /// The signal is emitted when client was connected
void onClientConnected();
+ /// The signal is emitted when client was disconnected
void onClientDisconnected();
protected slots:
+ /// Calls when client disconnected
void clientDisconnected();
+ /// When receive message from client prepare message by type of message
+ /// @param asMessage Message
void messageProcessing(const DapRpcMessage &asMessage);
// DapRpcAbstractServer interface
public slots:
+ /// Notify connected clients. Send all message
+ /// @param message Message to client
void notifyConnectedClients(const DapRpcMessage &message);
+ /// Notify connected clients. Send all message
+ /// @param method Method which clients were notified
+ /// @param params Parameters of message in JSON format
void notifyConnectedClients(const QString &method, const QJsonArray ¶ms);
};
--
GitLab