wirenboard / wb-mqtt-serial / 673

Committed 15 Jul 2025 07:07AM UTC coverage: 73.028% (-0.8%) from 73.863%

Build # 673

Build Type

push

github

Committed by

web-flow

Commit Message

Add device/Load and device/Set RPC

Run Details

6463 of 9217 branches covered (70.12%)

51 of 322 new or added lines in 13 files covered. (15.84%)

7 existing lines in 2 files now uncovered.

12368 of 16936 relevant lines covered (73.03%)

373.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/rpc/rpc_device_handler.h

#pragma once
#include "rpc_port_driver_list.h"
#include "templates_map.h"

const std::chrono::seconds DefaultRPCTotalTimeout(10);

class TRPCDeviceParametersCache
{
public:
    TRPCDeviceParametersCache() = default;

    /**
     * Registes DeviceConnectionStateChanged callbacks to remove cached data if device connection lost.
     */
    void RegisterCallbacks(PHandlerConfig handlerConfig);

    /**
     * Creates cache item identifier string based on simlified port description and device address.
     * For example: "/dev/ttyRS485-2:12" or "192.168.18.7:2321:33"
     */
    std::string GetId(const TPort& port, const std::string& slaveId) const;

    /**
     * Puts device paramerers data into cache.
     * This method is thread safe.
     */
    void Add(const std::string& id, const Json::Value& value);

    /**
     * Removes device paramerers data from cache.
     * This method is thread safe.
     */
    void Remove(const std::string& id);

    /**
     * Returns true if cache contains device paramerers data or false overwise.
     * This method is thread safe.
     */
    bool Contains(const std::string& id) const;

    /**
     * Returns device paramerers data if cache contains it or defaultData overwise.
     * This method is thread safe.
     */
    const Json::Value& Get(const std::string& id, const Json::Value& defaultValue = Json::Value()) const;

private:
    mutable std::mutex Mutex;
    std::unordered_map<std::string, Json::Value> DeviceParameters;
};

class TRPCDeviceHelper
{
public:
    TRPCDeviceHelper(const Json::Value& request,
                     const TSerialDeviceFactory& deviceFactory,
                     PTemplateMap templates,
                     TSerialClientTaskRunner& serialClientTaskRunner);

    TDeviceProtocolParams ProtocolParams;
    PSerialDevice Device;
    PDeviceTemplate DeviceTemplate;
    bool DeviceFromConfig = false;
};

class TRPCDeviceRequest
{
public:
    TRPCDeviceRequest(const TDeviceProtocolParams& protocolParams,
                      PSerialDevice device,
                      PDeviceTemplate deviceTemplate,
                      bool deviceFromConfig);

    TDeviceProtocolParams ProtocolParams;
    PSerialDevice Device;
    PDeviceTemplate DeviceTemplate;
    bool DeviceFromConfig;

    TSerialPortConnectionSettings SerialPortSettings;

    std::chrono::milliseconds ResponseTimeout = DefaultResponseTimeout;
    std::chrono::milliseconds FrameTimeout = DefaultFrameTimeout;
    std::chrono::milliseconds TotalTimeout = DefaultRPCTotalTimeout;

    WBMQTT::TMqttRpcServer::TResultCallback OnResult = nullptr;
    WBMQTT::TMqttRpcServer::TErrorCallback OnError = nullptr;

    void ParseSettings(const Json::Value& request,
                       WBMQTT::TMqttRpcServer::TResultCallback onResult,
                       WBMQTT::TMqttRpcServer::TErrorCallback onError);
};

class TRPCDeviceHandler
{
public:
    TRPCDeviceHandler(const std::string& requestDeviceLoadConfigSchemaFilePath,
                      const std::string& requestDeviceLoadSchemaFilePath,
                      const std::string& requestDeviceLSetSchemaFilePath,
                      const std::string& requestDeviceProbeSchemaFilePath,
                      const TSerialDeviceFactory& deviceFactory,
                      PTemplateMap templates,
                      TSerialClientTaskRunner& serialClientTaskRunner,
                      TRPCDeviceParametersCache& parametersCache,
                      WBMQTT::PMqttRpcServer rpcServer);

private:
    const TSerialDeviceFactory& DeviceFactory;

    Json::Value RequestDeviceLoadConfigSchema;
    Json::Value RequestDeviceLoadSchema;
    Json::Value RequestDeviceSetSchema;
    Json::Value RequestDeviceProbeSchema;
    PTemplateMap Templates;
    TSerialClientTaskRunner& SerialClientTaskRunner;
    TRPCDeviceParametersCache& ParametersCache;

    void LoadConfig(const Json::Value& request,
                    WBMQTT::TMqttRpcServer::TResultCallback onResult,
                    WBMQTT::TMqttRpcServer::TErrorCallback onError);

    void Load(const Json::Value& request,
              WBMQTT::TMqttRpcServer::TResultCallback onResult,
              WBMQTT::TMqttRpcServer::TErrorCallback onError);

    void Set(const Json::Value& request,
             WBMQTT::TMqttRpcServer::TResultCallback onResult,
             WBMQTT::TMqttRpcServer::TErrorCallback onError);

    void Probe(const Json::Value& request,
               WBMQTT::TMqttRpcServer::TResultCallback onResult,
               WBMQTT::TMqttRpcServer::TErrorCallback onError);
};

typedef std::shared_ptr<TRPCDeviceHandler> PRPCDeviceHandler;
typedef std::vector<std::pair<std::string, PRegister>> TRPCRegisterList;

/**
 * @brief Creates named PRegister map based on template items (channels/parameters) JSON array or object.
 *
 * @param protocolParams - device protocol params for LoadRegisterConfig call
 * @param device - serial device object pointer for TRegister object creation
 * @param templateItems - device template items JSON array or object
 * @param knownItems - known items JSON object, where the key is the item id and the value is the known
 *                     item value, for example: {"baudrate": 96, "in1_mode": 2},
 *                     used to exclule known items from regiter list
 * @param fwVersion - device firmvare version string, used to exclude items unsupporterd by firmware
 *
 * @return TRPCRegisterList - named PRegister list
 */
TRPCRegisterList CreateRegisterList(const TDeviceProtocolParams& protocolParams,
                                    const PSerialDevice& device,
                                    const Json::Value& templateItems,
                                    const Json::Value& knownItems = Json::Value(),
                                    const std::string& fwVersion = std::string());

/**
 * @brief Reads TRPCRegisterList registers and puts valuet to JSON object.
 *
 * @param port - serial port refrence
 * @param device - serial device object pointer
 * @param registerList - named PRegister map
 * @param result - result JSON object reference
 * @param maxRetries - number of request retries in case of error
 */
void ReadRegisterList(TPort& port,
                      PSerialDevice device,
                      TRPCRegisterList& registerList,
                      Json::Value& result,
                      int maxRetries = 0);

1	#pragma once
2	#include "rpc_port_driver_list.h"
3	#include "templates_map.h"
4
5	const std::chrono::seconds DefaultRPCTotalTimeout(10);
6
7	class TRPCDeviceParametersCache
8	{
9	public:
10	TRPCDeviceParametersCache() = default;	×
11
12	/**
13	* Registes DeviceConnectionStateChanged callbacks to remove cached data if device connection lost.
14	*/
15	void RegisterCallbacks(PHandlerConfig handlerConfig);
16
17	/**
18	* Creates cache item identifier string based on simlified port description and device address.
19	* For example: "/dev/ttyRS485-2:12" or "192.168.18.7:2321:33"
20	*/
21	std::string GetId(const TPort& port, const std::string& slaveId) const;
22
23	/**
24	* Puts device paramerers data into cache.
25	* This method is thread safe.
26	*/
27	void Add(const std::string& id, const Json::Value& value);
28
29	/**
30	* Removes device paramerers data from cache.
31	* This method is thread safe.
32	*/
33	void Remove(const std::string& id);
34
35	/**
36	* Returns true if cache contains device paramerers data or false overwise.
37	* This method is thread safe.
38	*/
39	bool Contains(const std::string& id) const;
40
41	/**
42	* Returns device paramerers data if cache contains it or defaultData overwise.
43	* This method is thread safe.
44	*/
45	const Json::Value& Get(const std::string& id, const Json::Value& defaultValue = Json::Value()) const;	×
46
47	private:
48	mutable std::mutex Mutex;
49	std::unordered_map<std::string, Json::Value> DeviceParameters;
50	};
51
52	class TRPCDeviceHelper
53	{
54	public:
55	TRPCDeviceHelper(const Json::Value& request,
56	const TSerialDeviceFactory& deviceFactory,
57	PTemplateMap templates,
58	TSerialClientTaskRunner& serialClientTaskRunner);
59
60	TDeviceProtocolParams ProtocolParams;
61	PSerialDevice Device;
62	PDeviceTemplate DeviceTemplate;
63	bool DeviceFromConfig = false;
64	};
65
66	class TRPCDeviceRequest
67	{
68	public:
69	TRPCDeviceRequest(const TDeviceProtocolParams& protocolParams,
70	PSerialDevice device,
71	PDeviceTemplate deviceTemplate,
72	bool deviceFromConfig);
73
74	TDeviceProtocolParams ProtocolParams;
75	PSerialDevice Device;
76	PDeviceTemplate DeviceTemplate;
77	bool DeviceFromConfig;
78
79	TSerialPortConnectionSettings SerialPortSettings;
80
81	std::chrono::milliseconds ResponseTimeout = DefaultResponseTimeout;
82	std::chrono::milliseconds FrameTimeout = DefaultFrameTimeout;
83	std::chrono::milliseconds TotalTimeout = DefaultRPCTotalTimeout;
84
85	WBMQTT::TMqttRpcServer::TResultCallback OnResult = nullptr;
86	WBMQTT::TMqttRpcServer::TErrorCallback OnError = nullptr;
87
88	void ParseSettings(const Json::Value& request,
89	WBMQTT::TMqttRpcServer::TResultCallback onResult,
90	WBMQTT::TMqttRpcServer::TErrorCallback onError);
91	};
92
93	class TRPCDeviceHandler
94	{
95	public:
96	TRPCDeviceHandler(const std::string& requestDeviceLoadConfigSchemaFilePath,
97	const std::string& requestDeviceLoadSchemaFilePath,
98	const std::string& requestDeviceLSetSchemaFilePath,
99	const std::string& requestDeviceProbeSchemaFilePath,
100	const TSerialDeviceFactory& deviceFactory,
101	PTemplateMap templates,
102	TSerialClientTaskRunner& serialClientTaskRunner,
103	TRPCDeviceParametersCache& parametersCache,
104	WBMQTT::PMqttRpcServer rpcServer);
105
106	private:
107	const TSerialDeviceFactory& DeviceFactory;
108
109	Json::Value RequestDeviceLoadConfigSchema;
110	Json::Value RequestDeviceLoadSchema;
111	Json::Value RequestDeviceSetSchema;
112	Json::Value RequestDeviceProbeSchema;
113	PTemplateMap Templates;
114	TSerialClientTaskRunner& SerialClientTaskRunner;
115	TRPCDeviceParametersCache& ParametersCache;
116
117	void LoadConfig(const Json::Value& request,
118	WBMQTT::TMqttRpcServer::TResultCallback onResult,
119	WBMQTT::TMqttRpcServer::TErrorCallback onError);
120
121	void Load(const Json::Value& request,
122	WBMQTT::TMqttRpcServer::TResultCallback onResult,
123	WBMQTT::TMqttRpcServer::TErrorCallback onError);
124
125	void Set(const Json::Value& request,
126	WBMQTT::TMqttRpcServer::TResultCallback onResult,
127	WBMQTT::TMqttRpcServer::TErrorCallback onError);
128
129	void Probe(const Json::Value& request,
130	WBMQTT::TMqttRpcServer::TResultCallback onResult,
131	WBMQTT::TMqttRpcServer::TErrorCallback onError);
132	};
133
134	typedef std::shared_ptr<TRPCDeviceHandler> PRPCDeviceHandler;
135	typedef std::vector<std::pair<std::string, PRegister>> TRPCRegisterList;
136
137	/**
138	* @brief Creates named PRegister map based on template items (channels/parameters) JSON array or object.
139	*
140	* @param protocolParams - device protocol params for LoadRegisterConfig call
141	* @param device - serial device object pointer for TRegister object creation
142	* @param templateItems - device template items JSON array or object
143	* @param knownItems - known items JSON object, where the key is the item id and the value is the known
144	* item value, for example: {"baudrate": 96, "in1_mode": 2},
145	* used to exclule known items from regiter list
146	* @param fwVersion - device firmvare version string, used to exclude items unsupporterd by firmware
147	*
148	* @return TRPCRegisterList - named PRegister list
149	*/
150	TRPCRegisterList CreateRegisterList(const TDeviceProtocolParams& protocolParams,
151	const PSerialDevice& device,
152	const Json::Value& templateItems,
NEW 153	const Json::Value& knownItems = Json::Value(),	×
NEW 154	const std::string& fwVersion = std::string());	×
155
156	/**
157	* @brief Reads TRPCRegisterList registers and puts valuet to JSON object.
158	*
159	* @param port - serial port refrence
160	* @param device - serial device object pointer
161	* @param registerList - named PRegister map
162	* @param result - result JSON object reference
163	* @param maxRetries - number of request retries in case of error
164	*/
165	void ReadRegisterList(TPort& port,
166	PSerialDevice device,
167	TRPCRegisterList& registerList,
168	Json::Value& result,
169	int maxRetries = 0);

wirenboard / wb-mqtt-serial / 673

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous