wirenboard / wb-mqtt-serial / 676

Committed 25 Jul 2025 11:44AM UTC coverage: 72.932%. Remained the same

Build # 676

Build Type

push

github

Committed by

web-flow

Commit Message

Revert "Merge branch 'feature/modbus-tcp-rpc'"

Run Details

6463 of 9226 branches covered (70.05%)

0 of 5 new or added lines in 2 files covered. (0.0%)

26 existing lines in 1 file now uncovered.

12370 of 16961 relevant lines covered (72.93%)

373.1 hits per line

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

0.0

/src/rpc/rpc_port_handler.cpp

#include "rpc_port_handler.h"
#include "rpc_helpers.h"
#include "rpc_port_load_modbus_serial_client_task.h"
#include "rpc_port_load_raw_serial_client_task.h"
#include "rpc_port_scan_serial_client_task.h"
#include "rpc_port_setup_serial_client_task.h"

#define LOG(logger) ::logger.Log() << "[RPC] "

TRPCPortHandler::TRPCPortHandler(const std::string& requestPortLoadSchemaFilePath,
                                 const std::string& requestPortSetupSchemaFilePath,
                                 const std::string& requestPortScanSchemaFilePath,
                                 PRPCConfig rpcConfig,
                                 TSerialClientTaskRunner& serialClientTaskRunner,
                                 TRPCDeviceParametersCache& parametersCache,
                                 WBMQTT::PMqttRpcServer rpcServer)
    : RequestPortLoadSchema(LoadRPCRequestSchema(requestPortLoadSchemaFilePath, "port/Load")),
      RequestPortSetupSchema(LoadRPCRequestSchema(requestPortSetupSchemaFilePath, "port/Setup")),
      RequestPortScanSchema(LoadRPCRequestSchema(requestPortScanSchemaFilePath, "port/Scan")),
      RPCConfig(rpcConfig),
      SerialClientTaskRunner(serialClientTaskRunner),
      ParametersCache(parametersCache)
{
    rpcServer->RegisterAsyncMethod("port",
                                   "Load",
                                   std::bind(&TRPCPortHandler::PortLoad,
                                             this,
                                             std::placeholders::_1,
                                             std::placeholders::_2,
                                             std::placeholders::_3));
    rpcServer->RegisterMethod("ports", "Load", std::bind(&TRPCPortHandler::LoadPorts, this, std::placeholders::_1));
    rpcServer->RegisterAsyncMethod("port",
                                   "Setup",
                                   std::bind(&TRPCPortHandler::PortSetup,
                                             this,
                                             std::placeholders::_1,
                                             std::placeholders::_2,
                                             std::placeholders::_3));
    rpcServer->RegisterAsyncMethod("port",
                                   "Scan",
                                   std::bind(&TRPCPortHandler::PortScan,
                                             this,
                                             std::placeholders::_1,
                                             std::placeholders::_2,
                                             std::placeholders::_3));
}

void TRPCPortHandler::PortLoad(const Json::Value& request,
                               WBMQTT::TMqttRpcServer::TResultCallback onResult,
                               WBMQTT::TMqttRpcServer::TErrorCallback onError)
{
    ValidateRPCRequest(request, RequestPortLoadSchema);
    try {
        auto protocol = request.get("protocol", "raw").asString();
        if (protocol == "modbus") {
            SerialClientTaskRunner.RunTask(
                request,
                std::make_shared<TRPCPortLoadModbusSerialClientTask>(request, onResult, onError, ParametersCache));
        } else {
            SerialClientTaskRunner.RunTask(
                request,
                std::make_shared<TRPCPortLoadRawSerialClientTask>(request, onResult, onError));
        }
    } catch (const TRPCException& e) {
        ProcessException(e, onError);
    }
}

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

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

Json::Value TRPCPortHandler::LoadPorts(const Json::Value& request)
{
    return RPCConfig->GetPortConfigs();
}

1	#include "rpc_port_handler.h"
2	#include "rpc_helpers.h"
3	#include "rpc_port_load_modbus_serial_client_task.h"
4	#include "rpc_port_load_raw_serial_client_task.h"
5	#include "rpc_port_scan_serial_client_task.h"
6	#include "rpc_port_setup_serial_client_task.h"
7
8	#define LOG(logger) ::logger.Log() << "[RPC] "
9
10	TRPCPortHandler::TRPCPortHandler(const std::string& requestPortLoadSchemaFilePath,	×
11	const std::string& requestPortSetupSchemaFilePath,
12	const std::string& requestPortScanSchemaFilePath,
13	PRPCConfig rpcConfig,
14	TSerialClientTaskRunner& serialClientTaskRunner,
15	TRPCDeviceParametersCache& parametersCache,
16	WBMQTT::PMqttRpcServer rpcServer)	×
17	: RequestPortLoadSchema(LoadRPCRequestSchema(requestPortLoadSchemaFilePath, "port/Load")),	×
18	RequestPortSetupSchema(LoadRPCRequestSchema(requestPortSetupSchemaFilePath, "port/Setup")),	×
19	RequestPortScanSchema(LoadRPCRequestSchema(requestPortScanSchemaFilePath, "port/Scan")),	×
20	RPCConfig(rpcConfig),
21	SerialClientTaskRunner(serialClientTaskRunner),
22	ParametersCache(parametersCache)	×
23	{
24	rpcServer->RegisterAsyncMethod("port",	×
25	"Load",
26	std::bind(&TRPCPortHandler::PortLoad,	×
27	this,	×
28	std::placeholders::_1,
29	std::placeholders::_2,
30	std::placeholders::_3));	×
31	rpcServer->RegisterMethod("ports", "Load", std::bind(&TRPCPortHandler::LoadPorts, this, std::placeholders::_1));	×
32	rpcServer->RegisterAsyncMethod("port",	×
33	"Setup",
34	std::bind(&TRPCPortHandler::PortSetup,	×
35	this,	×
36	std::placeholders::_1,
37	std::placeholders::_2,
38	std::placeholders::_3));	×
39	rpcServer->RegisterAsyncMethod("port",	×
40	"Scan",
41	std::bind(&TRPCPortHandler::PortScan,	×
42	this,	×
43	std::placeholders::_1,
44	std::placeholders::_2,
45	std::placeholders::_3));	×
46	}
47
48	void TRPCPortHandler::PortLoad(const Json::Value& request,	×
49	WBMQTT::TMqttRpcServer::TResultCallback onResult,
50	WBMQTT::TMqttRpcServer::TErrorCallback onError)
51	{
52	ValidateRPCRequest(request, RequestPortLoadSchema);	×
53	try {
54	auto protocol = request.get("protocol", "raw").asString();	×
NEW 55	if (protocol == "modbus") {	×
56	SerialClientTaskRunner.RunTask(	×
57	request,
58	std::make_shared<TRPCPortLoadModbusSerialClientTask>(request, onResult, onError, ParametersCache));	×
59	} else {
60	SerialClientTaskRunner.RunTask(	×
61	request,
62	std::make_shared<TRPCPortLoadRawSerialClientTask>(request, onResult, onError));	×
63	}
64	} catch (const TRPCException& e) {	×
65	ProcessException(e, onError);	×
66	}
67	}
68
69	void TRPCPortHandler::PortSetup(const Json::Value& request,	×
70	WBMQTT::TMqttRpcServer::TResultCallback onResult,
71	WBMQTT::TMqttRpcServer::TErrorCallback onError)
72	{
73	ValidateRPCRequest(request, RequestPortSetupSchema);	×
74	try {
75	SerialClientTaskRunner.RunTask(request,	×
76	std::make_shared<TRPCPortSetupSerialClientTask>(request, onResult, onError));	×
77	} catch (const TRPCException& e) {	×
78	ProcessException(e, onError);	×
79	}
80	}
81
82	void TRPCPortHandler::PortScan(const Json::Value& request,	×
83	WBMQTT::TMqttRpcServer::TResultCallback onResult,
84	WBMQTT::TMqttRpcServer::TErrorCallback onError)
85	{
86	ValidateRPCRequest(request, RequestPortScanSchema);	×
87	try {
88	SerialClientTaskRunner.RunTask(request,	×
89	std::make_shared<TRPCPortScanSerialClientTask>(request, onResult, onError));	×
90	} catch (const TRPCException& e) {	×
91	ProcessException(e, onError);	×
92	}
93	}
94
95	Json::Value TRPCPortHandler::LoadPorts(const Json::Value& request)	×
96	{
97	return RPCConfig->GetPortConfigs();	×
98	}

wirenboard / wb-mqtt-serial / 676

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