wirenboard / wb-mqtt-serial / 2

Committed 20 Oct 2026 05:26AM UTC coverage: 86.772% (+13.9%) from 72.836%

Build # 2

Build Type

Pull #1283

github

Specific Base e3f11f

Committed by

KraPete

Commit Message

Remove comment from service unit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Pull Request Pull Request #1283: Order service after mosquitto and restart it without limit

Coverage Stats

31090 of 80727 branches covered (38.51%)

22401 of 25816 relevant lines covered (86.77%)

2589.67 hits per line

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

91.21

/src/pollable_device.cpp

#include "pollable_device.h"

bool TRegisterComparePredicate::operator()(const PRegister& r1, const PRegister& r2) const
{
    if (r1->GetConfig()->Type != r2->GetConfig()->Type) {
        return r1->GetConfig()->Type > r2->GetConfig()->Type;
    }
    auto cmp = r1->GetConfig()->GetAddress().Compare(r2->GetConfig()->GetAddress());
    if (cmp != 0) {
        return cmp > 0;
    }
    // addresses are equal, compare offsets
    return r1->GetConfig()->GetDataOffset() > r2->GetConfig()->GetDataOffset();
}

TPollableDevice::TPollableDevice(PSerialDevice device,
                                 std::chrono::steady_clock::time_point currentTime,
                                 TPriority priority)
    : Device(device),
      Priority(priority),
      DisconnectedPollDelay(0)
{
    for (const auto& reg: Device->GetRegisters()) {
        if ((Priority == TPriority::High && reg->GetConfig()->IsHighPriority()) ||
            (Priority == TPriority::Low && !reg->GetConfig()->IsHighPriority()))
        {
            if (reg->GetConfig()->AccessType != TRegisterConfig::EAccessType::WRITE_ONLY) {
                Registers.AddEntry(reg, currentTime);
            }
        }
    }
}

PRegisterRange TPollableDevice::ReadRegisterRange(TFeaturePort& port,
                                                  std::chrono::milliseconds pollLimit,
                                                  bool readAtLeastOneRegister,
                                                  const util::TSpentTimeMeter& sessionTime,
                                                  TSerialClientDeviceAccessHandler& lastAccessedDevice)
{
    auto currentTime = sessionTime.GetStartTime();
    auto registerRange = Device->CreateRegisterRange();
    while (Registers.HasReadyItems(currentTime)) {
        const auto limit = (readAtLeastOneRegister && registerRange->RegisterList().empty())
                               ? std::chrono::milliseconds::max()
                               : pollLimit;
        const auto& item = Registers.GetTop();
        if (!registerRange->Add(port, item.Data, limit)) {
            break;
        }
        Registers.Pop();
    }

    if (!registerRange->RegisterList().empty()) {
        bool readOk = false;
        if (lastAccessedDevice.PrepareToAccess(port, Device)) {
            Device->ReadRegisterRange(port, registerRange);
            readOk = true;
        }

        for (auto& reg: registerRange->RegisterList()) {
            reg->SetLastPollTime(currentTime);
            if (!readOk) {
                reg->SetError(TRegister::TError::ReadError);
            }
        }

        for (const auto& reg: registerRange->RegisterList()) {
            ScheduleNextPoll(reg, currentTime);
        }

        Device->SetLastReadTime(currentTime + sessionTime.GetSpentTime());
    }

    return registerRange;
}

std::list<PRegister> TPollableDevice::MarkWaitingRegistersAsReadErrorAndReschedule(
    std::chrono::steady_clock::time_point currentTime)
{
    std::list<PRegister> res;
    while (Registers.HasReadyItems(currentTime)) {
        res.push_back(Registers.GetTop().Data);
        Registers.Pop();
    }
    for (const auto& reg: res) {
        ScheduleNextPoll(reg, currentTime);
    }
    return res;
}

std::chrono::steady_clock::time_point TPollableDevice::GetDeadline() const
{
    if (Priority == TPriority::Low && Device->DeviceConfig()->MinRequestInterval != std::chrono::milliseconds::zero()) {
        auto deadline = Registers.GetDeadline();
        auto minNextReadTime = Device->GetLastReadTime() + Device->DeviceConfig()->MinRequestInterval;
        return minNextReadTime > deadline ? minNextReadTime : deadline;
    }
    return Registers.GetDeadline();
}

std::chrono::milliseconds TPollableDevice::GetDisconnectedPollDelay() const
{
    return DisconnectedPollDelay;
}

void TPollableDevice::SetDisconnectedPollDelay(const std::chrono::milliseconds& delay)
{
    DisconnectedPollDelay = delay;
}

TPriority TPollableDevice::GetPriority() const
{
    return Priority;
}

PSerialDevice TPollableDevice::GetDevice() const
{
    return Device;
}

bool TPollableDevice::HasRegisters() const
{
    return !Registers.IsEmpty();
}

void TPollableDevice::RescheduleAllRegisters()
{
    for (const auto& reg: Device->GetRegisters()) {
        if ((Priority == TPriority::High && reg->GetConfig()->IsHighPriority()) ||
            (Priority == TPriority::Low && !reg->GetConfig()->IsHighPriority()))
        {
            if (reg->GetConfig()->AccessType != TRegisterConfig::EAccessType::WRITE_ONLY) {
                if (reg->IsExcludedFromPolling() && !Registers.Contains(reg)) {
                    reg->SetAvailable(TRegisterAvailability::UNKNOWN);
                    reg->IncludeInPolling();
                    Registers.AddEntry(reg, std::chrono::steady_clock::time_point());
                }
            }
        }
    }
}

void TPollableDevice::ScheduleNextPoll(PRegister reg, std::chrono::steady_clock::time_point currentTime)
{
    if (reg->IsExcludedFromPolling()) {
        // If register is sporadic it must be read once to get actual value
        // Keep polling it until successful read
        if (reg->GetValue().GetType() == TRegisterValue::ValueType::Undefined) {
            Registers.AddEntry(reg, currentTime + std::chrono::microseconds(1));
        }
        return;
    }
    if (Priority == TPriority::High) {
        Registers.AddEntry(reg, currentTime + *(reg->GetConfig()->ReadPeriod));
        return;
    }
    if (reg->GetConfig()->ReadRateLimit) {
        Registers.AddEntry(reg, currentTime + *(reg->GetConfig()->ReadRateLimit));
        return;
    }
    // Low priority registers should be scheduled to read as soon as possible,
    // but with a small delay after current read.
    Registers.AddEntry(reg, currentTime + std::chrono::microseconds(1));
}

1	#include "pollable_device.h"
2
3	bool TRegisterComparePredicate::operator()(const PRegister& r1, const PRegister& r2) const	2,092 ✔
4	{
5	if (r1->GetConfig()->Type != r2->GetConfig()->Type) {	2,092 !
6	return r1->GetConfig()->Type > r2->GetConfig()->Type;	488 !
7	}
8	auto cmp = r1->GetConfig()->GetAddress().Compare(r2->GetConfig()->GetAddress());	1,604 !
9	if (cmp != 0) {	1,604 ✔
10	return cmp > 0;	1,536 ✔
11	}
12	// addresses are equal, compare offsets
13	return r1->GetConfig()->GetDataOffset() > r2->GetConfig()->GetDataOffset();	68 !
14	}
15
16	TPollableDevice::TPollableDevice(PSerialDevice device,	464 ✔
17	std::chrono::steady_clock::time_point currentTime,
18	TPriority priority)	464 ✔
19	: Device(device),	464 ✔
20	Priority(priority),	464 ✔
21	DisconnectedPollDelay(0)	464 !
22	{
23	for (const auto& reg: Device->GetRegisters()) {	1,862 !
24	if ((Priority == TPriority::High && reg->GetConfig()->IsHighPriority()) \|\|	4,187 !
25	(Priority == TPriority::Low && !reg->GetConfig()->IsHighPriority()))	2,789 !
26	{
27	if (reg->GetConfig()->AccessType != TRegisterConfig::EAccessType::WRITE_ONLY) {	699 !
28	Registers.AddEntry(reg, currentTime);	697 !
29	}
30	}
31	}
32	}	464 ✔
33
34	PRegisterRange TPollableDevice::ReadRegisterRange(TFeaturePort& port,	4,527 ✔
35	std::chrono::milliseconds pollLimit,
36	bool readAtLeastOneRegister,
37	const util::TSpentTimeMeter& sessionTime,
38	TSerialClientDeviceAccessHandler& lastAccessedDevice)
39	{
40	auto currentTime = sessionTime.GetStartTime();	4,527 !
41	auto registerRange = Device->CreateRegisterRange();	4,527 !
42	while (Registers.HasReadyItems(currentTime)) {	9,466 !
43	const auto limit = (readAtLeastOneRegister && registerRange->RegisterList().empty())	5,324 !
44	? std::chrono::milliseconds::max()	9,867 ✔
45	: pollLimit;	5,423 ✔
46	const auto& item = Registers.GetTop();	5,423 !
47	if (!registerRange->Add(port, item.Data, limit)) {	5,423 !
48	break;	484 ✔
49	}
50	Registers.Pop();	4,939 !
51	}
52
53	if (!registerRange->RegisterList().empty()) {	4,527 !
54	bool readOk = false;	4,490 ✔
55	if (lastAccessedDevice.PrepareToAccess(port, Device)) {	4,490 !
56	Device->ReadRegisterRange(port, registerRange);	4,466 !
57	readOk = true;	4,466 ✔
58	}
59
60	for (auto& reg: registerRange->RegisterList()) {	9,418 !
61	reg->SetLastPollTime(currentTime);	4,928 !
62	if (!readOk) {	4,928 ✔
63	reg->SetError(TRegister::TError::ReadError);	42 !
64	}
65	}
66
67	for (const auto& reg: registerRange->RegisterList()) {	9,418 !
68	ScheduleNextPoll(reg, currentTime);	4,928 !
69	}
70
71	Device->SetLastReadTime(currentTime + sessionTime.GetSpentTime());	4,490 !
72	}
73
74	return registerRange;	4,527 ✔
75	}	×
76
77	std::list<PRegister> TPollableDevice::MarkWaitingRegistersAsReadErrorAndReschedule(	33 ✔
78	std::chrono::steady_clock::time_point currentTime)
79	{
80	std::list<PRegister> res;	33 ✔
81	while (Registers.HasReadyItems(currentTime)) {	70 !
82	res.push_back(Registers.GetTop().Data);	37 !
83	Registers.Pop();	37 !
84	}
85	for (const auto& reg: res) {	70 ✔
86	ScheduleNextPoll(reg, currentTime);	37 !
87	}
88	return res;	33 ✔
89	}	×
90
91	std::chrono::steady_clock::time_point TPollableDevice::GetDeadline() const	4,551 ✔
92	{
93	if (Priority == TPriority::Low && Device->DeviceConfig()->MinRequestInterval != std::chrono::milliseconds::zero()) {	4,551 !
94	auto deadline = Registers.GetDeadline();	×
95	auto minNextReadTime = Device->GetLastReadTime() + Device->DeviceConfig()->MinRequestInterval;	×
96	return minNextReadTime > deadline ? minNextReadTime : deadline;	×
97	}
98	return Registers.GetDeadline();	4,551 ✔
99	}
100
101	std::chrono::milliseconds TPollableDevice::GetDisconnectedPollDelay() const	94 ✔
102	{
103	return DisconnectedPollDelay;	94 ✔
104	}
105
106	void TPollableDevice::SetDisconnectedPollDelay(const std::chrono::milliseconds& delay)	4,523 ✔
107	{
108	DisconnectedPollDelay = delay;	4,523 ✔
109	}	4,523 ✔
110
111	TPriority TPollableDevice::GetPriority() const	14,006 ✔
112	{
113	return Priority;	14,006 ✔
114	}
115
116	PSerialDevice TPollableDevice::GetDevice() const	9,211 ✔
117	{
118	return Device;	9,211 ✔
119	}
120
121	bool TPollableDevice::HasRegisters() const	4,987 ✔
122	{
123	return !Registers.IsEmpty();	4,987 ✔
124	}
125
126	void TPollableDevice::RescheduleAllRegisters()	28 ✔
127	{
128	for (const auto& reg: Device->GetRegisters()) {	72 !
129	if ((Priority == TPriority::High && reg->GetConfig()->IsHighPriority()) \|\|	131 !
130	(Priority == TPriority::Low && !reg->GetConfig()->IsHighPriority()))	87 !
131	{
132	if (reg->GetConfig()->AccessType != TRegisterConfig::EAccessType::WRITE_ONLY) {	42 !
133	if (reg->IsExcludedFromPolling() && !Registers.Contains(reg)) {	42 !
134	reg->SetAvailable(TRegisterAvailability::UNKNOWN);	×
135	reg->IncludeInPolling();	×
136	Registers.AddEntry(reg, std::chrono::steady_clock::time_point());	×
137	}
138	}
139	}
140	}
141	}	28 ✔
142
143	void TPollableDevice::ScheduleNextPoll(PRegister reg, std::chrono::steady_clock::time_point currentTime)	4,965 ✔
144	{
145	if (reg->IsExcludedFromPolling()) {	4,965 ✔
146	// If register is sporadic it must be read once to get actual value
147	// Keep polling it until successful read
148	if (reg->GetValue().GetType() == TRegisterValue::ValueType::Undefined) {	23 !
149	Registers.AddEntry(reg, currentTime + std::chrono::microseconds(1));	16 !
150	}
151	return;	23 ✔
152	}
153	if (Priority == TPriority::High) {	4,942 ✔
154	Registers.AddEntry(reg, currentTime + *(reg->GetConfig()->ReadPeriod));	42 !
155	return;	42 ✔
156	}
157	if (reg->GetConfig()->ReadRateLimit) {	4,900 !
158	Registers.AddEntry(reg, currentTime + *(reg->GetConfig()->ReadRateLimit));	14 !
159	return;	14 ✔
160	}
161	// Low priority registers should be scheduled to read as soon as possible,
162	// but with a small delay after current read.
163	Registers.AddEntry(reg, currentTime + std::chrono::microseconds(1));	4,886 !
164	}

wirenboard / wb-mqtt-serial / 2

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