wirenboard / wb-mqtt-serial / 7

Committed 26 Nov 2025 06:26AM UTC coverage: 76.773% (-0.1%) from 76.899%

Build # 7

Build Type

push

github

Committed by

u236

Commit Message

Merge remote-tracking branch 'origin/master' into wasm

Run Details

6865 of 9158 branches covered (74.96%)

17 of 112 new or added lines in 10 files covered. (15.18%)

6 existing lines in 2 files now uncovered.

12957 of 16877 relevant lines covered (76.77%)

825.72 hits per line

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

0.0

/src/rpc/rpc_device_load_task.cpp

#include "rpc_device_load_task.h"
#include "config_merge_template.h"
#include "rpc_helpers.h"

namespace
{
    void ExecRPCRequest(PPort port, PRPCDeviceLoadRequest rpcRequest)
    {
        if (!rpcRequest->OnResult) {
            return;
        }
        Json::Value result(Json::objectValue);
        for (int i = 0; i < 2; i++) {
            auto registerList = i ? rpcRequest->GetParametersRegisterList() : rpcRequest->GetChannelsRegisterList();
            if (!registerList.empty()) {
                ReadRegisterList(*port, rpcRequest->Device, registerList, result[i ? "parameters" : "channels"]);
            }
        }
        rpcRequest->OnResult(result);
    }
} // namespace

TRPCDeviceLoadRequest::TRPCDeviceLoadRequest(const TDeviceProtocolParams& protocolParams,
                                             PSerialDevice device,
                                             PDeviceTemplate deviceTemplate,
                                             bool deviceFromConfig)
    : TRPCDeviceRequest(protocolParams, device, deviceTemplate, deviceFromConfig)
{}

void TRPCDeviceLoadRequest::ParseRequestItems(const Json::Value& items, std::list<std::string>& list)
{
    for (const auto& item: items) {
        auto id = item.asString();
        if (std::find(list.begin(), list.end(), id) == list.end()) {
            list.push_back(id);
        }
    }
}

TRPCRegisterList TRPCDeviceLoadRequest::GetChannelsRegisterList()
{
    Json::Value items(Json::arrayValue);
    for (auto item: DeviceTemplate->GetTemplate()["channels"]) {
        if (item["address"].isNull()) { // write only channel
            continue;
        }
        auto id = item["name"].asString();
        if (std::find(Channels.begin(), Channels.end(), id) != Channels.end()) {
            item["id"] = id;
            items.append(item);
            Channels.remove(id);
        }
    }
    if (!Channels.empty()) {
        throw TRPCException("Channel \"" + Channels.front() + "\" is write only or not found in \"" +
                                DeviceTemplate->Type + "\" device template",
                            TRPCResultCode::RPC_WRONG_PARAM_VALUE);
    }
    return CreateRegisterList(ProtocolParams, Device, items);
}

TRPCRegisterList TRPCDeviceLoadRequest::GetParametersRegisterList()
{
    auto params = DeviceTemplate->GetTemplate()["parameters"];
    Json::Value items(Json::arrayValue);
    for (auto it = params.begin(); it != params.end(); ++it) {
        auto item = *it;
        if (item["address"].isNull()) { // write only parameter
            continue;
        }
        auto id = params.isObject() ? it.key().asString() : item["id"].asString();
        if (std::find(Parameters.begin(), Parameters.end(), id) != Parameters.end()) {
            if (params.isObject()) {
                item["id"] = id;
            }
            items.append(item);
            Parameters.remove(id);
        }
    }
    if (!Channels.empty()) {
        throw TRPCException("Parameter \"" + Parameters.front() + "\" is write only or not found in \"" +
                                DeviceTemplate->Type + "\" device template",
                            TRPCResultCode::RPC_WRONG_PARAM_VALUE);
    }
    return CreateRegisterList(ProtocolParams, Device, items);
}

PRPCDeviceLoadRequest ParseRPCDeviceLoadRequest(const Json::Value& request,
                                                const TDeviceProtocolParams& protocolParams,
                                                PSerialDevice device,
                                                PDeviceTemplate deviceTemplate,
                                                bool deviceFromConfig,
                                                WBMQTT::TMqttRpcServer::TResultCallback onResult,
                                                WBMQTT::TMqttRpcServer::TErrorCallback onError)
{
    auto res = std::make_shared<TRPCDeviceLoadRequest>(protocolParams, device, deviceTemplate, deviceFromConfig);
    res->ParseSettings(request, onResult, onError);
    res->ParseRequestItems(request["channels"], res->Channels);
    res->ParseRequestItems(request["parameters"], res->Parameters);
    return res;
}

TRPCDeviceLoadSerialClientTask::TRPCDeviceLoadSerialClientTask(PRPCDeviceLoadRequest request): Request(request)
{
    ExpireTime = std::chrono::steady_clock::now() + Request->TotalTimeout;
}

ISerialClientTask::TRunResult TRPCDeviceLoadSerialClientTask::Run(PFeaturePort port,
                                                                  TSerialClientDeviceAccessHandler& lastAccessedDevice,
                                                                  const std::list<PSerialDevice>& polledDevices)
{
    if (std::chrono::steady_clock::now() > ExpireTime) {
        if (Request->OnError) {
            Request->OnError(WBMQTT::E_RPC_REQUEST_TIMEOUT, "RPC request timeout");
        }
        return ISerialClientTask::TRunResult::OK;
    }
    try {
        if (!port->IsOpen()) {
            port->Open();
        }
        lastAccessedDevice.PrepareToAccess(*port, nullptr);
        if (!Request->DeviceFromConfig) {
            TSerialPortSettingsGuard settingsGuard(port, Request->SerialPortSettings);
            ExecRPCRequest(port, Request);
        } else {
            ExecRPCRequest(port, Request);
        }
    } catch (const std::exception& error) {
        if (Request->OnError) {
            Request->OnError(WBMQTT::E_RPC_SERVER_ERROR, std::string("Port IO error: ") + error.what());
        }
    }
    return ISerialClientTask::TRunResult::OK;
}

1	#include "rpc_device_load_task.h"
2	#include "config_merge_template.h"
3	#include "rpc_helpers.h"
4
5	namespace
6	{
7	void ExecRPCRequest(PPort port, PRPCDeviceLoadRequest rpcRequest)	×
8	{
9	if (!rpcRequest->OnResult) {	×
10	return;	×
11	}
NEW 12	Json::Value result(Json::objectValue);	×
13	for (int i = 0; i < 2; i++) {	×
14	auto registerList = i ? rpcRequest->GetParametersRegisterList() : rpcRequest->GetChannelsRegisterList();	×
15	if (!registerList.empty()) {	×
16	ReadRegisterList(*port, rpcRequest->Device, registerList, result[i ? "parameters" : "channels"]);	×
17	}
18	}
19	rpcRequest->OnResult(result);	×
20	}
21	} // namespace
22
23	TRPCDeviceLoadRequest::TRPCDeviceLoadRequest(const TDeviceProtocolParams& protocolParams,	×
24	PSerialDevice device,
25	PDeviceTemplate deviceTemplate,
26	bool deviceFromConfig)	×
27	: TRPCDeviceRequest(protocolParams, device, deviceTemplate, deviceFromConfig)	×
28	{}
29
30	void TRPCDeviceLoadRequest::ParseRequestItems(const Json::Value& items, std::list<std::string>& list)	×
31	{
32	for (const auto& item: items) {	×
33	auto id = item.asString();	×
34	if (std::find(list.begin(), list.end(), id) == list.end()) {	×
35	list.push_back(id);	×
36	}
37	}
38	}
39
40	TRPCRegisterList TRPCDeviceLoadRequest::GetChannelsRegisterList()	×
41	{
42	Json::Value items(Json::arrayValue);	×
43	for (auto item: DeviceTemplate->GetTemplate()["channels"]) {	×
44	if (item["address"].isNull()) { // write only channel	×
45	continue;	×
46	}
47	auto id = item["name"].asString();	×
48	if (std::find(Channels.begin(), Channels.end(), id) != Channels.end()) {	×
49	item["id"] = id;	×
50	items.append(item);	×
51	Channels.remove(id);	×
52	}
53	}
54	if (!Channels.empty()) {	×
55	throw TRPCException("Channel \"" + Channels.front() + "\" is write only or not found in \"" +	×
56	DeviceTemplate->Type + "\" device template",	×
57	TRPCResultCode::RPC_WRONG_PARAM_VALUE);	×
58	}
59	return CreateRegisterList(ProtocolParams, Device, items);	×
60	}
61
62	TRPCRegisterList TRPCDeviceLoadRequest::GetParametersRegisterList()	×
63	{
64	auto params = DeviceTemplate->GetTemplate()["parameters"];	×
65	Json::Value items(Json::arrayValue);	×
66	for (auto it = params.begin(); it != params.end(); ++it) {	×
67	auto item = *it;	×
68	if (item["address"].isNull()) { // write only parameter	×
69	continue;	×
70	}
71	auto id = params.isObject() ? it.key().asString() : item["id"].asString();	×
72	if (std::find(Parameters.begin(), Parameters.end(), id) != Parameters.end()) {	×
73	if (params.isObject()) {	×
74	item["id"] = id;	×
75	}
76	items.append(item);	×
77	Parameters.remove(id);	×
78	}
79	}
80	if (!Channels.empty()) {	×
81	throw TRPCException("Parameter \"" + Parameters.front() + "\" is write only or not found in \"" +	×
82	DeviceTemplate->Type + "\" device template",	×
83	TRPCResultCode::RPC_WRONG_PARAM_VALUE);	×
84	}
85	return CreateRegisterList(ProtocolParams, Device, items);	×
86	}
87
88	PRPCDeviceLoadRequest ParseRPCDeviceLoadRequest(const Json::Value& request,	×
89	const TDeviceProtocolParams& protocolParams,
90	PSerialDevice device,
91	PDeviceTemplate deviceTemplate,
92	bool deviceFromConfig,
93	WBMQTT::TMqttRpcServer::TResultCallback onResult,
94	WBMQTT::TMqttRpcServer::TErrorCallback onError)
95	{
96	auto res = std::make_shared<TRPCDeviceLoadRequest>(protocolParams, device, deviceTemplate, deviceFromConfig);	×
97	res->ParseSettings(request, onResult, onError);	×
98	res->ParseRequestItems(request["channels"], res->Channels);	×
99	res->ParseRequestItems(request["parameters"], res->Parameters);	×
100	return res;	×
101	}
102
103	TRPCDeviceLoadSerialClientTask::TRPCDeviceLoadSerialClientTask(PRPCDeviceLoadRequest request): Request(request)	×
104	{
105	ExpireTime = std::chrono::steady_clock::now() + Request->TotalTimeout;	×
106	}
107
108	ISerialClientTask::TRunResult TRPCDeviceLoadSerialClientTask::Run(PFeaturePort port,	×
109	TSerialClientDeviceAccessHandler& lastAccessedDevice,
110	const std::list<PSerialDevice>& polledDevices)
111	{
112	if (std::chrono::steady_clock::now() > ExpireTime) {	×
113	if (Request->OnError) {	×
114	Request->OnError(WBMQTT::E_RPC_REQUEST_TIMEOUT, "RPC request timeout");	×
115	}
116	return ISerialClientTask::TRunResult::OK;	×
117	}
118	try {
119	if (!port->IsOpen()) {	×
120	port->Open();	×
121	}
122	lastAccessedDevice.PrepareToAccess(*port, nullptr);	×
123	if (!Request->DeviceFromConfig) {	×
124	TSerialPortSettingsGuard settingsGuard(port, Request->SerialPortSettings);	×
NEW 125	ExecRPCRequest(port, Request);	×
126	} else {
NEW 127	ExecRPCRequest(port, Request);	×
128	}
129	} catch (const std::exception& error) {	×
130	if (Request->OnError) {	×
131	Request->OnError(WBMQTT::E_RPC_SERVER_ERROR, std::string("Port IO error: ") + error.what());	×
132	}
133	}
134	return ISerialClientTask::TRunResult::OK;	×
135	}

wirenboard / wb-mqtt-serial / 7

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