wirenboard / wb-mqtt-w1 / 50

Committed 31 Jul 2026 10:39AM UTC coverage: 61.341% (-0.5%) from 61.795%

Build # 50

Build Type

push

github

Committed by

web-flow

Commit Message

Use exported vars instead of MAKEFLAGS for coverage options (#36)

Coverage Stats

172 of 248 branches covered (69.35%)

311 of 507 relevant lines covered (61.34%)

4.55 hits per line

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

0.0

/main.cpp

#include <getopt.h>

#include "onewire_driver.h"
#include "threaded_runner.h"
#include <wblib/signal_handling.h>
#include <wblib/utils.h>
#include <wblib/wbmqtt.h>

using namespace std;

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

WBMQTT::TLogger Error("ERROR: ", WBMQTT::TLogger::StdErr, WBMQTT::TLogger::RED);
WBMQTT::TLogger Info("INFO: ", WBMQTT::TLogger::StdErr, WBMQTT::TLogger::GREY);
WBMQTT::TLogger Debug("DEBUG: ", WBMQTT::TLogger::StdErr, WBMQTT::TLogger::WHITE, false);

const auto WBMQTT_DB_FILE = "/var/lib/wb-mqtt-w1/libwbmqtt.db";
const auto W1_DRIVER_INIT_TIMEOUT_S = chrono::seconds(5);
const auto W1_DRIVER_STOP_TIMEOUT_S = chrono::seconds(5); // topic cleanup can take a lot of time
const uint32_t DEFAULT_POLL_INTERVALL_MS = 10000;

namespace
{
    void PrintUsage()
    {
        cout << "Usage:" << endl
             << "  wb-mqtt-w1 [options]" << endl
             << "Options:" << endl
             << "  -d level     enable debuging output:" << endl
             << "                 1 - 1-Wire only;" << endl
             << "                 2 - mqtt only;" << endl
             << "                 3 - both;" << endl
             << "                 negative values - silent mode (-1, -2, -3))" << endl
             << "  -p port      MQTT broker port (default: 1883)" << endl
             << "  -h IP        MQTT broker IP (default: localhost)" << endl
             << "  -u user      MQTT user (optional)" << endl
             << "  -P password  MQTT user password (optional)" << endl
             << "  -i interval  polling interval, ms (default: " << DEFAULT_POLL_INTERVALL_MS << " ms)" << endl;
    }

    void ParseCommadLine(int argc, char* argv[], WBMQTT::TMosquittoMqttConfig& mqttConfig, uint32_t& pollingInterval)
    {
        int debugLevel = 0;
        int c;

        while ((c = getopt(argc, argv, "d:i:h:p:u:P:")) != -1) {
            switch (c) {
                case 'd':
                    debugLevel = stoi(optarg);
                    break;
                case 'p':
                    mqttConfig.Port = stoi(optarg);
                    break;
                case 'h':
                    mqttConfig.Host = optarg;
                    break;
                case 'i':
                    pollingInterval = stoul(optarg);
                    break;
                case 'u':
                    mqttConfig.User = optarg;
                    break;
                case 'P':
                    mqttConfig.Password = optarg;
                    break;

                case '?':
                default:
                    PrintUsage();
                    exit(2);
            }
        }

        switch (debugLevel) {
            case 0:
                break;
            case -1:
                ::Info.SetEnabled(false);
                break;

            case -2:
                WBMQTT::Info.SetEnabled(false);
                break;

            case -3:
                WBMQTT::Info.SetEnabled(false);
                ::Info.SetEnabled(false);
                break;

            case 1:
                ::Debug.SetEnabled(true);
                break;

            case 2:
                WBMQTT::Debug.SetEnabled(true);
                break;

            case 3:
                WBMQTT::Debug.SetEnabled(true);
                ::Debug.SetEnabled(true);
                break;

            default:
                cout << "Invalid -d parameter value " << debugLevel << endl;
                PrintUsage();
                exit(2);
        }

        if (optind < argc) {
            for (int index = optind; index < argc; ++index) {
                cout << "Skipping unknown argument " << argv[index] << endl;
            }
        }
    }
} // namespace

int main(int argc, char* argv[])
{
    WBMQTT::TPromise<void> initialized;

    WBMQTT::SetThreadName("main");
    WBMQTT::SignalHandling::Handle({SIGINT, SIGTERM});
    WBMQTT::SignalHandling::OnSignals({SIGINT, SIGTERM}, [&] { WBMQTT::SignalHandling::Stop(); });

    /* if signal arrived before driver is initialized:
        wait some time to initialize and then exit gracefully
        else if timed out: exit with error
    */
    WBMQTT::SignalHandling::SetWaitFor(W1_DRIVER_INIT_TIMEOUT_S, initialized.GetFuture(), [&] {
        LOG(Error) << "Driver takes too long to initialize. Exiting.";
        cerr << "Error: W1_DRIVER_INIT_TIMEOUT_S" << endl;
        exit(1);
    });

    /* if handling of signal takes too much time: exit with error */
    WBMQTT::SignalHandling::SetOnTimeout(W1_DRIVER_STOP_TIMEOUT_S, [&] {
        LOG(Error) << "Driver takes too long to stop. Exiting.";
        cerr << "Error: W1_DRIVER_STOP_TIMEOUT_S" << endl;
        exit(2);
    });
    WBMQTT::SignalHandling::Start();

    WBMQTT::TMosquittoMqttConfig mqttConfig{};
    mqttConfig.Id = "wb-w1";
    uint32_t pollInterval = DEFAULT_POLL_INTERVALL_MS;
    ParseCommadLine(argc, argv, mqttConfig, pollInterval);

    cout << "MQTT broker " << mqttConfig.Host << ':' << mqttConfig.Port << endl;

    auto mqttDriver =
        WBMQTT::NewDriver(WBMQTT::TDriverArgs{}
                              .SetBackend(WBMQTT::NewDriverBackend(WBMQTT::NewMosquittoMqttClient(mqttConfig)))
                              .SetId(mqttConfig.Id)
                              .SetUseStorage(false)
                              .SetReownUnknownDevices(true)
                              .SetStoragePath(WBMQTT_DB_FILE));

    mqttDriver->StartLoop();
    mqttDriver->WaitForReady();

    try {
        {
            TThreadedPeriodicalRunner r(
                std::unique_ptr<IPeriodicalWorker>(
                    new TOneWireDriverWorker("wb-w1", mqttDriver, ::Info, ::Debug, ::Error, "/sys/bus/w1/devices/")),
                std::chrono::milliseconds(pollInterval),
                "w1 thread",
                ::Info);

            initialized.Complete();
            WBMQTT::SignalHandling::Wait();
        }
        mqttDriver->StopLoop();
        mqttDriver->Close();

    } catch (const exception& e) {
        LOG(Error) << "FATAL: " << e.what();
        return 1;
    }

    return 0;
}

1	#include <getopt.h>
2
3	#include "onewire_driver.h"
4	#include "threaded_runner.h"
5	#include <wblib/signal_handling.h>
6	#include <wblib/utils.h>
7	#include <wblib/wbmqtt.h>
8
9	using namespace std;
10
11	#define LOG(logger) ::logger.Log() << "[w1] "
12
13	WBMQTT::TLogger Error("ERROR: ", WBMQTT::TLogger::StdErr, WBMQTT::TLogger::RED);
14	WBMQTT::TLogger Info("INFO: ", WBMQTT::TLogger::StdErr, WBMQTT::TLogger::GREY);
15	WBMQTT::TLogger Debug("DEBUG: ", WBMQTT::TLogger::StdErr, WBMQTT::TLogger::WHITE, false);
16
17	const auto WBMQTT_DB_FILE = "/var/lib/wb-mqtt-w1/libwbmqtt.db";
18	const auto W1_DRIVER_INIT_TIMEOUT_S = chrono::seconds(5);
19	const auto W1_DRIVER_STOP_TIMEOUT_S = chrono::seconds(5); // topic cleanup can take a lot of time
20	const uint32_t DEFAULT_POLL_INTERVALL_MS = 10000;
21
22	namespace
23	{
24	void PrintUsage()	×
25	{
26	cout << "Usage:" << endl	×
27	<< " wb-mqtt-w1 [options]" << endl	×
28	<< "Options:" << endl	×
29	<< " -d level enable debuging output:" << endl	×
30	<< " 1 - 1-Wire only;" << endl	×
31	<< " 2 - mqtt only;" << endl	×
32	<< " 3 - both;" << endl	×
33	<< " negative values - silent mode (-1, -2, -3))" << endl	×
34	<< " -p port MQTT broker port (default: 1883)" << endl	×
35	<< " -h IP MQTT broker IP (default: localhost)" << endl	×
36	<< " -u user MQTT user (optional)" << endl	×
37	<< " -P password MQTT user password (optional)" << endl	×
38	<< " -i interval polling interval, ms (default: " << DEFAULT_POLL_INTERVALL_MS << " ms)" << endl;	×
39	}	×
40
41	void ParseCommadLine(int argc, char* argv[], WBMQTT::TMosquittoMqttConfig& mqttConfig, uint32_t& pollingInterval)	×
42	{
43	int debugLevel = 0;	×
44	int c;
45
46	while ((c = getopt(argc, argv, "d:i:h:p:u:P:")) != -1) {	×
47	switch (c) {	×
48	case 'd':	×
49	debugLevel = stoi(optarg);	×
50	break;	×
51	case 'p':	×
52	mqttConfig.Port = stoi(optarg);	×
53	break;	×
54	case 'h':	×
55	mqttConfig.Host = optarg;	×
56	break;	×
57	case 'i':	×
58	pollingInterval = stoul(optarg);	×
59	break;	×
60	case 'u':	×
61	mqttConfig.User = optarg;	×
62	break;	×
63	case 'P':	×
64	mqttConfig.Password = optarg;	×
65	break;	×
66
67	case '?':	×
68	default:
69	PrintUsage();	×
70	exit(2);	×
71	}
72	}
73
74	switch (debugLevel) {	×
75	case 0:	×
76	break;	×
77	case -1:	×
78	::Info.SetEnabled(false);	×
79	break;	×
80
81	case -2:	×
82	WBMQTT::Info.SetEnabled(false);	×
83	break;	×
84
85	case -3:	×
86	WBMQTT::Info.SetEnabled(false);	×
87	::Info.SetEnabled(false);	×
88	break;	×
89
90	case 1:	×
91	::Debug.SetEnabled(true);	×
92	break;	×
93
94	case 2:	×
95	WBMQTT::Debug.SetEnabled(true);	×
96	break;	×
97
98	case 3:	×
99	WBMQTT::Debug.SetEnabled(true);	×
100	::Debug.SetEnabled(true);	×
101	break;	×
102
103	default:	×
104	cout << "Invalid -d parameter value " << debugLevel << endl;	×
105	PrintUsage();	×
106	exit(2);	×
107	}
108
109	if (optind < argc) {	×
110	for (int index = optind; index < argc; ++index) {	×
111	cout << "Skipping unknown argument " << argv[index] << endl;	×
112	}
113	}
114	}	×
115	} // namespace
116
117	int main(int argc, char* argv[])	×
118	{
119	WBMQTT::TPromise<void> initialized;	×
120
121	WBMQTT::SetThreadName("main");	×
122	WBMQTT::SignalHandling::Handle({SIGINT, SIGTERM});	×
123	WBMQTT::SignalHandling::OnSignals({SIGINT, SIGTERM}, [&] { WBMQTT::SignalHandling::Stop(); });	×
124
125	/* if signal arrived before driver is initialized:
126	wait some time to initialize and then exit gracefully
127	else if timed out: exit with error
128	*/
129	WBMQTT::SignalHandling::SetWaitFor(W1_DRIVER_INIT_TIMEOUT_S, initialized.GetFuture(), [&] {	×
130	LOG(Error) << "Driver takes too long to initialize. Exiting.";	×
131	cerr << "Error: W1_DRIVER_INIT_TIMEOUT_S" << endl;	×
132	exit(1);	×
133	});
134
135	/* if handling of signal takes too much time: exit with error */
136	WBMQTT::SignalHandling::SetOnTimeout(W1_DRIVER_STOP_TIMEOUT_S, [&] {	×
137	LOG(Error) << "Driver takes too long to stop. Exiting.";	×
138	cerr << "Error: W1_DRIVER_STOP_TIMEOUT_S" << endl;	×
139	exit(2);	×
140	});
141	WBMQTT::SignalHandling::Start();	×
142
143	WBMQTT::TMosquittoMqttConfig mqttConfig{};	×
144	mqttConfig.Id = "wb-w1";	×
145	uint32_t pollInterval = DEFAULT_POLL_INTERVALL_MS;	×
146	ParseCommadLine(argc, argv, mqttConfig, pollInterval);	×
147
148	cout << "MQTT broker " << mqttConfig.Host << ':' << mqttConfig.Port << endl;	×
149
150	auto mqttDriver =
151	WBMQTT::NewDriver(WBMQTT::TDriverArgs{}	×
152	.SetBackend(WBMQTT::NewDriverBackend(WBMQTT::NewMosquittoMqttClient(mqttConfig)))	×
153	.SetId(mqttConfig.Id)	×
154	.SetUseStorage(false)	×
155	.SetReownUnknownDevices(true)	×
156	.SetStoragePath(WBMQTT_DB_FILE));	×
157
158	mqttDriver->StartLoop();	×
159	mqttDriver->WaitForReady();	×
160
161	try {
162	{
163	TThreadedPeriodicalRunner r(
164	std::unique_ptr<IPeriodicalWorker>(	×
165	new TOneWireDriverWorker("wb-w1", mqttDriver, ::Info, ::Debug, ::Error, "/sys/bus/w1/devices/")),	×
166	std::chrono::milliseconds(pollInterval),	×
167	"w1 thread",
168	::Info);	×
169
170	initialized.Complete();	×
171	WBMQTT::SignalHandling::Wait();	×
172	}	×
173	mqttDriver->StopLoop();	×
174	mqttDriver->Close();	×
175
176	} catch (const exception& e) {	×
177	LOG(Error) << "FATAL: " << e.what();	×
178	return 1;	×
179	}	×
180
181	return 0;	×
182	}	×

wirenboard / wb-mqtt-w1 / 50

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