wirenboard / wb-mqtt-serial / 10

Committed 03 Jul 2025 11:45AM UTC coverage: 73.72% (-0.1%) from 73.835%

Build # 10

Build Type

Pull #956

github

Committed by

u236

Commit Message

revert template with subdevices exception

Pull Request Pull Request #956: Refactor device/LoadConfig RPC

Run Details

6427 of 9056 branches covered (70.97%)

0 of 111 new or added lines in 4 files covered. (0.0%)

8 existing lines in 3 files now uncovered.

12278 of 16655 relevant lines covered (73.72%)

306.59 hits per line

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

0.0

/src/rpc/rpc_device_handler.cpp

#include "rpc_device_handler.h"
#include "rpc_device_load_config_task.h"
#include "rpc_device_probe_task.h"
#include "rpc_helpers.h"

void TRPCDeviceParametersCache::RegisterCallbacks(PHandlerConfig handlerConfig)
{
    for (const auto& portConfig: handlerConfig->PortConfigs) {
        for (const auto& device: portConfig->Devices) {
            std::string id = GetId(*portConfig->Port, device->Device->DeviceConfig()->SlaveId);
            device->Device->AddOnConnectionStateChangedCallback([this, id](PSerialDevice device) {
                if (device->GetConnectionState() == TDeviceConnectionState::DISCONNECTED) {
                    Remove(id);
                }
            });
        }
    }
}

std::string TRPCDeviceParametersCache::GetId(const TPort& port, const std::string& slaveId) const
{
    return port.GetDescription(false) + ":" + slaveId;
}

void TRPCDeviceParametersCache::Add(const std::string& id, const Json::Value& value)
{
    std::unique_lock lock(Mutex);
    DeviceParameters[id] = value;
}

void TRPCDeviceParametersCache::Remove(const std::string& id)
{
    std::unique_lock lock(Mutex);
    DeviceParameters.erase(id);
}

bool TRPCDeviceParametersCache::Contains(const std::string& id) const
{
    std::unique_lock lock(Mutex);
    return DeviceParameters.find(id) != DeviceParameters.end();
}

const Json::Value& TRPCDeviceParametersCache::Get(const std::string& id, const Json::Value& defaultValue) const
{
    std::unique_lock lock(Mutex);
    auto it = DeviceParameters.find(id);
    return it != DeviceParameters.end() ? it->second : defaultValue;
};

TRPCDeviceReuest::TRPCDeviceReuest(const Json::Value& request,
                                   const TSerialDeviceFactory& deviceFactory,
                                   PTemplateMap templates,
                                   TSerialClientTaskRunner& serialClientTaskRunner)
{
    SerialClient = serialClientTaskRunner.GetSerialClient(request, Device);
    if (SerialClient == nullptr) {
        TaskExecutor = serialClientTaskRunner.GetTaskExecutor(request);
    }
    if (Device == nullptr) {
        DeviceTemplate = templates->GetTemplate(request["device_type"].asString());
        auto config = std::make_shared<TDeviceConfig>("RPC Device",
                                                      request["slave_id"].asString(),
                                                      DeviceTemplate->GetProtocol());
        if (DeviceTemplate->GetProtocol() == "modbus") {
            config->MaxRegHole = Modbus::MAX_HOLE_CONTINUOUS_16_BIT_REGISTERS;
            config->MaxBitHole = Modbus::MAX_HOLE_CONTINUOUS_1_BIT_REGISTERS;
            config->MaxReadRegisters = Modbus::MAX_READ_REGISTERS;
        }
        ProtocolParams = deviceFactory.GetProtocolParams(DeviceTemplate->GetProtocol());
        Device = ProtocolParams.factory->CreateDevice(DeviceTemplate->GetTemplate(),
                                                      config,
                                                      SerialClient ? SerialClient->GetPort() : TaskExecutor->GetPort(),
                                                      ProtocolParams.protocol);
    } else {
        DeviceTemplate = templates->GetTemplate(Device->DeviceConfig()->DeviceType);
        ProtocolParams = deviceFactory.GetProtocolParams(DeviceTemplate->GetProtocol());
        DeviceFromConfig = true;
    }
    if (DeviceTemplate->WithSubdevices()) {
        throw TRPCException("Device \"" + DeviceTemplate->Type + "\" is not supported by this RPC",
                            TRPCResultCode::RPC_WRONG_PARAM_VALUE);
    }
}

void TRPCDeviceReuest::RunTask(PSerialClientTask task)
{
    if (SerialClient) {
        SerialClient->AddTask(task);
    } else {
        TaskExecutor->AddTask(task);
    }
}

TRPCDeviceHandler::TRPCDeviceHandler(const std::string& requestDeviceLoadConfigSchemaFilePath,
                                     const std::string& requestDeviceProbeSchemaFilePath,
                                     const TSerialDeviceFactory& deviceFactory,
                                     PTemplateMap templates,
                                     TSerialClientTaskRunner& serialClientTaskRunner,
                                     TRPCDeviceParametersCache& parametersCache,
                                     WBMQTT::PMqttRpcServer rpcServer)
    : DeviceFactory(deviceFactory),
      RequestDeviceLoadConfigSchema(LoadRPCRequestSchema(requestDeviceLoadConfigSchemaFilePath, "device/LoadConfig")),
      RequestDeviceProbeSchema(LoadRPCRequestSchema(requestDeviceProbeSchemaFilePath, "device/Probe")),
      Templates(templates),
      SerialClientTaskRunner(serialClientTaskRunner),
      ParametersCache(parametersCache)
{
    rpcServer->RegisterAsyncMethod("device",
                                   "LoadConfig",
                                   std::bind(&TRPCDeviceHandler::LoadConfig,
                                             this,
                                             std::placeholders::_1,
                                             std::placeholders::_2,
                                             std::placeholders::_3));
    rpcServer->RegisterAsyncMethod("device",
                                   "Probe",
                                   std::bind(&TRPCDeviceHandler::Probe,
                                             this,
                                             std::placeholders::_1,
                                             std::placeholders::_2,
                                             std::placeholders::_3));
}

void TRPCDeviceHandler::LoadConfig(const Json::Value& request,
                                   WBMQTT::TMqttRpcServer::TResultCallback onResult,
                                   WBMQTT::TMqttRpcServer::TErrorCallback onError)
{
    ValidateRPCRequest(request, RequestDeviceLoadConfigSchema);
    try {
        auto deviceRequest = TRPCDeviceReuest(request, DeviceFactory, Templates, SerialClientTaskRunner);
        auto rpcRequest = ParseRPCDeviceLoadConfigRequest(request,
                                                          deviceRequest.ProtocolParams,
                                                          deviceRequest.Device,
                                                          deviceRequest.DeviceTemplate,
                                                          deviceRequest.DeviceFromConfig,
                                                          ParametersCache,
                                                          onResult,
                                                          onError);
        deviceRequest.RunTask(std::make_shared<TRPCDeviceLoadConfigSerialClientTask>(rpcRequest));
    } catch (const TRPCException& e) {
        ProcessException(e, onError);
    }
}

void TRPCDeviceHandler::Probe(const Json::Value& request,
                              WBMQTT::TMqttRpcServer::TResultCallback onResult,
                              WBMQTT::TMqttRpcServer::TErrorCallback onError)
{
    ValidateRPCRequest(request, RequestDeviceProbeSchema);
    try {
        SerialClientTaskRunner.RunTask(request,
                                       std::make_shared<TRPCDeviceProbeSerialClientTask>(request, onResult, onError));
    } catch (const TRPCException& e) {
        ProcessException(e, onError);
    }
}

1	#include "rpc_device_handler.h"
2	#include "rpc_device_load_config_task.h"
3	#include "rpc_device_probe_task.h"
4	#include "rpc_helpers.h"
5
UNCOV 6	void TRPCDeviceParametersCache::RegisterCallbacks(PHandlerConfig handlerConfig)	×
7	{
8	for (const auto& portConfig: handlerConfig->PortConfigs) {	×
9	for (const auto& device: portConfig->Devices) {	×
10	std::string id = GetId(*portConfig->Port, device->Device->DeviceConfig()->SlaveId);	×
11	device->Device->AddOnConnectionStateChangedCallback([this, id](PSerialDevice device) {	×
12	if (device->GetConnectionState() == TDeviceConnectionState::DISCONNECTED) {	×
13	Remove(id);	×
14	}
15	});	×
16	}
17	}
18	}
19
20	std::string TRPCDeviceParametersCache::GetId(const TPort& port, const std::string& slaveId) const	×
21	{
22	return port.GetDescription(false) + ":" + slaveId;	×
23	}
24
25	void TRPCDeviceParametersCache::Add(const std::string& id, const Json::Value& value)	×
26	{
27	std::unique_lock lock(Mutex);	×
28	DeviceParameters[id] = value;	×
29	}
30
31	void TRPCDeviceParametersCache::Remove(const std::string& id)	×
32	{
33	std::unique_lock lock(Mutex);	×
34	DeviceParameters.erase(id);	×
35	}
36
37	bool TRPCDeviceParametersCache::Contains(const std::string& id) const	×
38	{
39	std::unique_lock lock(Mutex);	×
40	return DeviceParameters.find(id) != DeviceParameters.end();	×
41	}
42
43	const Json::Value& TRPCDeviceParametersCache::Get(const std::string& id, const Json::Value& defaultValue) const	×
44	{
45	std::unique_lock lock(Mutex);	×
46	auto it = DeviceParameters.find(id);	×
47	return it != DeviceParameters.end() ? it->second : defaultValue;	×
48	};
49
NEW 50	TRPCDeviceReuest::TRPCDeviceReuest(const Json::Value& request,	×
51	const TSerialDeviceFactory& deviceFactory,
52	PTemplateMap templates,
NEW 53	TSerialClientTaskRunner& serialClientTaskRunner)	×
54	{
NEW 55	SerialClient = serialClientTaskRunner.GetSerialClient(request, Device);	×
NEW 56	if (SerialClient == nullptr) {	×
NEW 57	TaskExecutor = serialClientTaskRunner.GetTaskExecutor(request);	×
58	}
NEW 59	if (Device == nullptr) {	×
NEW 60	DeviceTemplate = templates->GetTemplate(request["device_type"].asString());	×
61	auto config = std::make_shared<TDeviceConfig>("RPC Device",
NEW 62	request["slave_id"].asString(),	×
NEW 63	DeviceTemplate->GetProtocol());	×
NEW 64	if (DeviceTemplate->GetProtocol() == "modbus") {	×
NEW 65	config->MaxRegHole = Modbus::MAX_HOLE_CONTINUOUS_16_BIT_REGISTERS;	×
NEW 66	config->MaxBitHole = Modbus::MAX_HOLE_CONTINUOUS_1_BIT_REGISTERS;	×
NEW 67	config->MaxReadRegisters = Modbus::MAX_READ_REGISTERS;	×
68	}
NEW 69	ProtocolParams = deviceFactory.GetProtocolParams(DeviceTemplate->GetProtocol());	×
NEW 70	Device = ProtocolParams.factory->CreateDevice(DeviceTemplate->GetTemplate(),	×
71	config,
NEW 72	SerialClient ? SerialClient->GetPort() : TaskExecutor->GetPort(),	×
NEW 73	ProtocolParams.protocol);	×
74	} else {
NEW 75	DeviceTemplate = templates->GetTemplate(Device->DeviceConfig()->DeviceType);	×
NEW 76	ProtocolParams = deviceFactory.GetProtocolParams(DeviceTemplate->GetProtocol());	×
NEW 77	DeviceFromConfig = true;	×
78	}
NEW 79	if (DeviceTemplate->WithSubdevices()) {	×
NEW 80	throw TRPCException("Device \"" + DeviceTemplate->Type + "\" is not supported by this RPC",	×
NEW 81	TRPCResultCode::RPC_WRONG_PARAM_VALUE);	×
82	}
83	}
84
NEW 85	void TRPCDeviceReuest::RunTask(PSerialClientTask task)	×
86	{
NEW 87	if (SerialClient) {	×
NEW 88	SerialClient->AddTask(task);	×
89	} else {
NEW 90	TaskExecutor->AddTask(task);	×
91	}
92	}
93
UNCOV 94	TRPCDeviceHandler::TRPCDeviceHandler(const std::string& requestDeviceLoadConfigSchemaFilePath,	×
95	const std::string& requestDeviceProbeSchemaFilePath,
96	const TSerialDeviceFactory& deviceFactory,
97	PTemplateMap templates,
98	TSerialClientTaskRunner& serialClientTaskRunner,
99	TRPCDeviceParametersCache& parametersCache,
100	WBMQTT::PMqttRpcServer rpcServer)	×
101	: DeviceFactory(deviceFactory),
102	RequestDeviceLoadConfigSchema(LoadRPCRequestSchema(requestDeviceLoadConfigSchemaFilePath, "device/LoadConfig")),	×
103	RequestDeviceProbeSchema(LoadRPCRequestSchema(requestDeviceProbeSchemaFilePath, "device/Probe")),	×
104	Templates(templates),
105	SerialClientTaskRunner(serialClientTaskRunner),
106	ParametersCache(parametersCache)	×
107	{
108	rpcServer->RegisterAsyncMethod("device",	×
109	"LoadConfig",
110	std::bind(&TRPCDeviceHandler::LoadConfig,	×
111	this,	×
112	std::placeholders::_1,
113	std::placeholders::_2,
114	std::placeholders::_3));	×
115	rpcServer->RegisterAsyncMethod("device",	×
116	"Probe",
117	std::bind(&TRPCDeviceHandler::Probe,	×
118	this,	×
119	std::placeholders::_1,
120	std::placeholders::_2,
121	std::placeholders::_3));	×
122	}
123
124	void TRPCDeviceHandler::LoadConfig(const Json::Value& request,	×
125	WBMQTT::TMqttRpcServer::TResultCallback onResult,
126	WBMQTT::TMqttRpcServer::TErrorCallback onError)
127	{
128	ValidateRPCRequest(request, RequestDeviceLoadConfigSchema);	×
129	try {
NEW 130	auto deviceRequest = TRPCDeviceReuest(request, DeviceFactory, Templates, SerialClientTaskRunner);	×
131	auto rpcRequest = ParseRPCDeviceLoadConfigRequest(request,
132	deviceRequest.ProtocolParams,
133	deviceRequest.Device,
134	deviceRequest.DeviceTemplate,
135	deviceRequest.DeviceFromConfig,
136	ParametersCache,
137	onResult,
NEW 138	onError);	×
NEW 139	deviceRequest.RunTask(std::make_shared<TRPCDeviceLoadConfigSerialClientTask>(rpcRequest));	×
140	} catch (const TRPCException& e) {	×
141	ProcessException(e, onError);	×
142	}
143	}
144
145	void TRPCDeviceHandler::Probe(const Json::Value& request,	×
146	WBMQTT::TMqttRpcServer::TResultCallback onResult,
147	WBMQTT::TMqttRpcServer::TErrorCallback onError)
148	{
149	ValidateRPCRequest(request, RequestDeviceProbeSchema);	×
150	try {
151	SerialClientTaskRunner.RunTask(request,	×
152	std::make_shared<TRPCDeviceProbeSerialClientTask>(request, onResult, onError));	×
153	} catch (const TRPCException& e) {	×
154	ProcessException(e, onError);	×
155	}
156	}

wirenboard / wb-mqtt-serial / 10

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