wirenboard / wb-mqtt-adc / 51

Committed 22 Aug 2025 08:50AM UTC coverage: 57.332% (-0.4%) from 57.722%

Build # 51

Build Type

push

github

Committed by

web-flow

Commit Message

Cleanup deb packaging (#49)

Run Details

250 of 430 branches covered (58.14%)

434 of 757 relevant lines covered (57.33%)

4.71 hits per line

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

60.42

/src/config.cpp

#include "config.h"
#include <algorithm>
#include <chrono>
#include <fstream>
#include <numeric>
#include <wblib/json_utils.h>
#include <wblib/utils.h>

#include "file_utils.h"

using namespace Json;
using namespace WBMQTT::JSON;
using namespace std;

namespace
{
    const string ProtectedProperties[] = {"match_iio",
                                          "channel_number",
                                          "mqtt_type",
                                          "voltage_multiplier",
                                          "max_voltage"};

    void LoadChannel(const Value& item, vector<TADCChannelSettings>& channels)
    {
        TADCChannelSettings channel;

        Get(item, "id", channel.Id);
        Get(item, "averaging_window", channel.ReaderCfg.AveragingWindow);
        if (Get(item, "max_voltage", channel.ReaderCfg.MaxScaledVoltage))
            channel.ReaderCfg.MaxScaledVoltage *= 1000;
        Get(item, "voltage_multiplier", channel.ReaderCfg.VoltageMultiplier);
        Get(item, "decimal_places", channel.ReaderCfg.DecimalPlaces);
        Get(item, "scale", channel.ReaderCfg.DesiredScale);
        Get(item, "poll_interval", channel.ReaderCfg.PollInterval);
        Get(item, "delay_between_measurements", channel.ReaderCfg.DelayBetweenMeasurements);
        Get(item, "match_iio", channel.MatchIIO);

        Value v = item["channel_number"];
        if (v.isInt()) {
            channel.ReaderCfg.ChannelNumber = "voltage" + to_string(v.asInt());
        } else {
            channel.ReaderCfg.ChannelNumber = v.asString();
        }
        channels.push_back(channel);
    }

    /*! This function recalculates delay between measurements if it is too large for
        selected poll interval. If so, measurements will be evenly distributed in interval
    */
    void MaybeFixDelayBetweenMeasurements(TConfig& cfg, WBMQTT::TLogger* log)
    {
        for (auto& ch: cfg.Channels) {
            auto calcMeasureDelay = ch.ReaderCfg.DelayBetweenMeasurements * ch.ReaderCfg.AveragingWindow;
            if (calcMeasureDelay > ch.ReaderCfg.PollInterval) {
                if (log) {
                    log->Log() << ch.Id << ": averaging delay doesn't fit in poll_interval, "
                               << "adjusting delay_between_measurements";
                }

                ch.ReaderCfg.DelayBetweenMeasurements = ch.ReaderCfg.PollInterval / ch.ReaderCfg.AveragingWindow;
            }
        }
    }

    Value Load(const string& filePath, const Value& schema)
    {
        auto json = Parse(filePath);
        Validate(json, schema);
        return json;
    }

    TConfig LoadFromJSON(const Value& configJson)
    {
        TConfig config;

        Get(configJson, "device_name", config.DeviceName);
        Get(configJson, "debug", config.EnableDebugMessages);
        Get(configJson, "max_unchanged_interval", config.MaxUnchangedInterval);

        const auto& ch = configJson["iio_channels"];
        for_each(ch.begin(), ch.end(), [&](const Value& v) { LoadChannel(v, config.Channels); });

        return config;
    }

    Value RemoveDeviceNameRequirement(const Value& schema)
    {
        Value newArray = arrayValue;
        for (auto& v: schema["required"]) {
            if (v.asString() != "device_name") {
                newArray.append(v);
            }
        }
        Value res(schema);
        res["required"] = newArray;
        return res;
    }
} // namespace

TConfig LoadConfig(const string& mainConfigFile,
                   const string& optionalConfigFile,
                   const string& systemConfigDir,
                   const string& schemaFile,
                   WBMQTT::TLogger* infoLogger,
                   WBMQTT::TLogger* warnLogger)
{
    auto schema = Parse(schemaFile);

    if (!optionalConfigFile.empty()) {
        return LoadFromJSON(Load(optionalConfigFile, schema));
    }

    auto noDeviceNameSchema = RemoveDeviceNameRequirement(schema);

    TMergeParams mergeParams;
    mergeParams.LogPrefix = "[config] ";
    mergeParams.InfoLogger = infoLogger;
    mergeParams.WarnLogger = warnLogger;
    mergeParams.MergeArraysOn["/iio_channels"] = "id";

    Json::Value resultingConfig;
    resultingConfig["iio_channels"] = Json::Value(Json::arrayValue);

    try {
        IterateDirByPattern(systemConfigDir, ".conf", [&](const string& f) {
            Merge(resultingConfig, Load(f, noDeviceNameSchema), mergeParams);
            return false;
        });
    } catch (const TNoDirError&) {
    }

    for (const auto& pr: ProtectedProperties) {
        mergeParams.ProtectedParameters.insert("/iio_channels/" + pr);
    }
    Merge(resultingConfig, Load(mainConfigFile, schema), mergeParams);
    auto cfg = LoadFromJSON(resultingConfig);
    MaybeFixDelayBetweenMeasurements(cfg, infoLogger);
    return cfg;
}

void MakeJsonForConfed(const string& configFile, const string& systemConfigsDir, const string& schemaFile)
{
    auto schema = Parse(schemaFile);
    auto noDeviceNameSchema = RemoveDeviceNameRequirement(schema);
    auto config = Load(configFile, schema);
    unordered_map<string, Value> configuredChannels;
    for (const auto& ch: config["iio_channels"]) {
        configuredChannels.emplace(ch["id"].asString(), ch);
    }
    Value newChannels(arrayValue);
    try {
        IterateDirByPattern(systemConfigsDir, ".conf", [&](const string& f) {
            auto cfg = Load(f, noDeviceNameSchema);
            for (const auto& ch: cfg["iio_channels"]) {
                auto name = ch["id"].asString();
                auto it = configuredChannels.find(name);
                if (it != configuredChannels.end()) {
                    newChannels.append(it->second);
                    configuredChannels.erase(name);
                } else {
                    Value v;
                    v["id"] = ch["id"];
                    v["decimal_places"] = ch["decimal_places"];
                    newChannels.append(v);
                }
            }
            return false;
        });
    } catch (const TNoDirError&) {
    }
    for (const auto& ch: config["iio_channels"]) {
        auto it = configuredChannels.find(ch["id"].asString());
        if (it != configuredChannels.end()) {
            newChannels.append(ch);
        }
    }
    config["iio_channels"].swap(newChannels);
    MakeWriter("", "None")->write(config, &cout);
}

void MakeConfigFromConfed(const string& systemConfigsDir, const string& schemaFile)
{
    auto noDeviceNameSchema = RemoveDeviceNameRequirement(Parse(schemaFile));
    unordered_set<string> systemChannels;
    try {
        IterateDirByPattern(systemConfigsDir, ".conf", [&](const string& f) {
            auto cfg = Load(f, noDeviceNameSchema);
            for (const auto& ch: cfg["iio_channels"]) {
                systemChannels.insert(ch["id"].asString());
            }
            return false;
        });
    } catch (const TNoDirError&) {
    }

    Value config;
    CharReaderBuilder readerBuilder;
    String errs;

    if (!parseFromStream(readerBuilder, cin, &config, &errs)) {
        throw runtime_error("Failed to parse JSON:" + errs);
    }

    Value newChannels(arrayValue);
    for (auto& ch: config["iio_channels"]) {
        auto it = systemChannels.find(ch["id"].asString());
        if (it != systemChannels.end()) {
            for (const auto& pr: ProtectedProperties) {
                ch.removeMember(pr);
            }
            if (ch.size() > 1) {
                newChannels.append(ch);
            }
        } else {
            newChannels.append(ch);
        }
    }
    config["iio_channels"].swap(newChannels);
    MakeWriter("  ", "None")->write(config, &cout);
}

void MakeSchemaForConfed(const string& systemConfigsDir, const string& schemaFile, const string& schemaForConfedFile)
{
    auto schema = Parse(schemaFile);
    auto noDeviceNameSchema = RemoveDeviceNameRequirement(schema);
    unordered_set<string> systemChannels;
    try {
        IterateDirByPattern(systemConfigsDir, ".conf", [&](const string& f) {
            auto cfg = Load(f, noDeviceNameSchema);
            for (const auto& ch: cfg["iio_channels"]) {
                systemChannels.insert(ch["id"].asString());
            }
            return false;
        });
    } catch (const TNoDirError&) {
    }
    auto& notNode = schema["definitions"]["custom_channel"]["allOf"][1]["not"]["properties"]["id"]["enum"];
    auto& sysIdsNode = schema["definitions"]["system_channel"]["allOf"][1]["properties"]["id"]["enum"];
    for (const auto& id: systemChannels) {
        notNode.append(id);
        sysIdsNode.append(id);
    }
    ofstream f(schemaForConfedFile);
    MakeWriter("    ", "None")->write(schema, &f);
}

1	#include "config.h"
2	#include <algorithm>
3	#include <chrono>
4	#include <fstream>
5	#include <numeric>
6	#include <wblib/json_utils.h>
7	#include <wblib/utils.h>
8
9	#include "file_utils.h"
10
11	using namespace Json;
12	using namespace WBMQTT::JSON;
13	using namespace std;
14
15	namespace
16	{
17	const string ProtectedProperties[] = {"match_iio",
18	"channel_number",
19	"mqtt_type",
20	"voltage_multiplier",
21	"max_voltage"};
22
23	void LoadChannel(const Value& item, vector<TADCChannelSettings>& channels)	7✔
24	{
25	TADCChannelSettings channel;	14✔
26
27	Get(item, "id", channel.Id);	7✔
28	Get(item, "averaging_window", channel.ReaderCfg.AveragingWindow);	7✔
29	if (Get(item, "max_voltage", channel.ReaderCfg.MaxScaledVoltage))	7✔
30	channel.ReaderCfg.MaxScaledVoltage *= 1000;	1✔
31	Get(item, "voltage_multiplier", channel.ReaderCfg.VoltageMultiplier);	7✔
32	Get(item, "decimal_places", channel.ReaderCfg.DecimalPlaces);	7✔
33	Get(item, "scale", channel.ReaderCfg.DesiredScale);	7✔
34	Get(item, "poll_interval", channel.ReaderCfg.PollInterval);	7✔
35	Get(item, "delay_between_measurements", channel.ReaderCfg.DelayBetweenMeasurements);	7✔
36	Get(item, "match_iio", channel.MatchIIO);	7✔
37
38	Value v = item["channel_number"];	14✔
39	if (v.isInt()) {	7✔
40	channel.ReaderCfg.ChannelNumber = "voltage" + to_string(v.asInt());	×
41	} else {
42	channel.ReaderCfg.ChannelNumber = v.asString();	7✔
43	}
44	channels.push_back(channel);	7✔
45	}	7✔
46
47	/*! This function recalculates delay between measurements if it is too large for
48	selected poll interval. If so, measurements will be evenly distributed in interval
49	*/
50	void MaybeFixDelayBetweenMeasurements(TConfig& cfg, WBMQTT::TLogger* log)	5✔
51	{
52	for (auto& ch: cfg.Channels) {	11✔
53	auto calcMeasureDelay = ch.ReaderCfg.DelayBetweenMeasurements * ch.ReaderCfg.AveragingWindow;	6✔
54	if (calcMeasureDelay > ch.ReaderCfg.PollInterval) {	6✔
55	if (log) {	1✔
56	log->Log() << ch.Id << ": averaging delay doesn't fit in poll_interval, "	2✔
57	<< "adjusting delay_between_measurements";	1✔
58	}
59
60	ch.ReaderCfg.DelayBetweenMeasurements = ch.ReaderCfg.PollInterval / ch.ReaderCfg.AveragingWindow;	1✔
61	}
62	}
63	}	5✔
64
65	Value Load(const string& filePath, const Value& schema)	25✔
66	{
67	auto json = Parse(filePath);	25✔
68	Validate(json, schema);	25✔
69	return json;	18✔
70	}
71
72	TConfig LoadFromJSON(const Value& configJson)	6✔
73	{
74	TConfig config;	6✔
75
76	Get(configJson, "device_name", config.DeviceName);	6✔
77	Get(configJson, "debug", config.EnableDebugMessages);	6✔
78	Get(configJson, "max_unchanged_interval", config.MaxUnchangedInterval);	6✔
79
80	const auto& ch = configJson["iio_channels"];	6✔
81	for_each(ch.begin(), ch.end(), [&](const Value& v) { LoadChannel(v, config.Channels); });	13✔
82
83	return config;	6✔
84	}
85
86	Value RemoveDeviceNameRequirement(const Value& schema)	18✔
87	{
88	Value newArray = arrayValue;	36✔
89	for (auto& v: schema["required"]) {	54✔
90	if (v.asString() != "device_name") {	36✔
91	newArray.append(v);	18✔
92	}
93	}
94	Value res(schema);	18✔
95	res["required"] = newArray;	18✔
96	return res;	36✔
97	}
98	} // namespace
99
100	TConfig LoadConfig(const string& mainConfigFile,	16✔
101	const string& optionalConfigFile,
102	const string& systemConfigDir,
103	const string& schemaFile,
104	WBMQTT::TLogger* infoLogger,
105	WBMQTT::TLogger* warnLogger)
106	{
107	auto schema = Parse(schemaFile);	29✔
108
109	if (!optionalConfigFile.empty()) {	13✔
110	return LoadFromJSON(Load(optionalConfigFile, schema));	3✔
111	}
112
113	auto noDeviceNameSchema = RemoveDeviceNameRequirement(schema);	22✔
114
115	TMergeParams mergeParams;	22✔
116	mergeParams.LogPrefix = "[config] ";	11✔
117	mergeParams.InfoLogger = infoLogger;	11✔
118	mergeParams.WarnLogger = warnLogger;	11✔
119	mergeParams.MergeArraysOn["/iio_channels"] = "id";	11✔
120
121	Json::Value resultingConfig;	22✔
122	resultingConfig["iio_channels"] = Json::Value(Json::arrayValue);	11✔
123
124	try {
125	IterateDirByPattern(systemConfigDir, ".conf", [&](const string& f) {	5✔
126	Merge(resultingConfig, Load(f, noDeviceNameSchema), mergeParams);	5✔
127	return false;	5✔
128	});	28✔
129	} catch (const TNoDirError&) {	6✔
130	}
131
132	for (const auto& pr: ProtectedProperties) {	66✔
133	mergeParams.ProtectedParameters.insert("/iio_channels/" + pr);	55✔
134	}
135	Merge(resultingConfig, Load(mainConfigFile, schema), mergeParams);	11✔
136	auto cfg = LoadFromJSON(resultingConfig);	10✔
137	MaybeFixDelayBetweenMeasurements(cfg, infoLogger);	5✔
138	return cfg;	5✔
139	}
140
141	void MakeJsonForConfed(const string& configFile, const string& systemConfigsDir, const string& schemaFile)	×
142	{
143	auto schema = Parse(schemaFile);	×
144	auto noDeviceNameSchema = RemoveDeviceNameRequirement(schema);	×
145	auto config = Load(configFile, schema);	×
146	unordered_map<string, Value> configuredChannels;	×
147	for (const auto& ch: config["iio_channels"]) {	×
148	configuredChannels.emplace(ch["id"].asString(), ch);	×
149	}
150	Value newChannels(arrayValue);	×
151	try {
152	IterateDirByPattern(systemConfigsDir, ".conf", [&](const string& f) {	×
153	auto cfg = Load(f, noDeviceNameSchema);	×
154	for (const auto& ch: cfg["iio_channels"]) {	×
155	auto name = ch["id"].asString();	×
156	auto it = configuredChannels.find(name);	×
157	if (it != configuredChannels.end()) {	×
158	newChannels.append(it->second);	×
159	configuredChannels.erase(name);	×
160	} else {
161	Value v;	×
162	v["id"] = ch["id"];	×
163	v["decimal_places"] = ch["decimal_places"];	×
164	newChannels.append(v);	×
165	}
166	}
167	return false;	×
168	});	×
169	} catch (const TNoDirError&) {	×
170	}
171	for (const auto& ch: config["iio_channels"]) {	×
172	auto it = configuredChannels.find(ch["id"].asString());	×
173	if (it != configuredChannels.end()) {	×
174	newChannels.append(ch);	×
175	}
176	}
177	config["iio_channels"].swap(newChannels);	×
178	MakeWriter("", "None")->write(config, &cout);	×
179	}
180
181	void MakeConfigFromConfed(const string& systemConfigsDir, const string& schemaFile)	×
182	{
183	auto noDeviceNameSchema = RemoveDeviceNameRequirement(Parse(schemaFile));	×
184	unordered_set<string> systemChannels;	×
185	try {
186	IterateDirByPattern(systemConfigsDir, ".conf", [&](const string& f) {	×
187	auto cfg = Load(f, noDeviceNameSchema);	×
188	for (const auto& ch: cfg["iio_channels"]) {	×
189	systemChannels.insert(ch["id"].asString());	×
190	}
191	return false;	×
192	});	×
193	} catch (const TNoDirError&) {	×
194	}
195
196	Value config;	×
197	CharReaderBuilder readerBuilder;	×
198	String errs;	×
199
200	if (!parseFromStream(readerBuilder, cin, &config, &errs)) {	×
201	throw runtime_error("Failed to parse JSON:" + errs);	×
202	}
203
204	Value newChannels(arrayValue);	×
205	for (auto& ch: config["iio_channels"]) {	×
206	auto it = systemChannels.find(ch["id"].asString());	×
207	if (it != systemChannels.end()) {	×
208	for (const auto& pr: ProtectedProperties) {	×
209	ch.removeMember(pr);	×
210	}
211	if (ch.size() > 1) {	×
212	newChannels.append(ch);	×
213	}
214	} else {
215	newChannels.append(ch);	×
216	}
217	}
218	config["iio_channels"].swap(newChannels);	×
219	MakeWriter(" ", "None")->write(config, &cout);	×
220	}
221
222	void MakeSchemaForConfed(const string& systemConfigsDir, const string& schemaFile, const string& schemaForConfedFile)	7✔
223	{
224	auto schema = Parse(schemaFile);	14✔
225	auto noDeviceNameSchema = RemoveDeviceNameRequirement(schema);	14✔
226	unordered_set<string> systemChannels;	14✔
227	try {
228	IterateDirByPattern(systemConfigsDir, ".conf", [&](const string& f) {	7✔
229	auto cfg = Load(f, noDeviceNameSchema);	7✔
230	for (const auto& ch: cfg["iio_channels"]) {	14✔
231	systemChannels.insert(ch["id"].asString());	7✔
232	}
233	return false;	14✔
234	});	14✔
235	} catch (const TNoDirError&) {	×
236	}
237	auto& notNode = schema["definitions"]["custom_channel"]["allOf"][1]["not"]["properties"]["id"]["enum"];	7✔
238	auto& sysIdsNode = schema["definitions"]["system_channel"]["allOf"][1]["properties"]["id"]["enum"];	7✔
239	for (const auto& id: systemChannels) {	14✔
240	notNode.append(id);	7✔
241	sysIdsNode.append(id);	7✔
242	}
243	ofstream f(schemaForConfedFile);	14✔
244	MakeWriter(" ", "None")->write(schema, &f);	7✔
245	}	7✔

wirenboard / wb-mqtt-adc / 51

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