1001210836

Committed 12 Sep 2023 01:20PM UTC coverage: 79.201% (+0.09%) from 79.112%

Build # 1001210836

Build Type

push

gitlab-ci

Committed by

vpodzime

Commit Message

feat: Add support for signals delivering two strings

Ticket: MEN-6651
Changelog: none
Signed-off-by: Vratislav Podzimek <v.podzimek@mykolab.com>

Run Details

5731 of 7236 relevant lines covered (79.2%)

256.26 hits per line

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

88.37

/common/events/platform/boost/events.cpp

// Copyright 2023 Northern.tech AS
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.

#include <common/events.hpp>

#include <boost/asio.hpp>

#include <common/error.hpp>
#include <common/log.hpp>

namespace mender {
namespace common {
namespace events {

namespace asio = boost::asio;
namespace error = mender::common::error;
namespace log = mender::common::log;

void EventLoop::Run() {
        bool stopped = ctx_.stopped();
        if (stopped) {
                ctx_.restart();
        }
        ctx_.run();
        if (!stopped) {
                // For recursive invocations. If we were originally running, but we stopped and
                // exited this level, then keep the running state of the previous recursive level.
                ctx_.restart();
        }
}

void EventLoop::Stop() {
        ctx_.stop();
}

void EventLoop::Post(std::function<void()> func) {
        ctx_.post(func);
}

Timer::Timer(EventLoop &loop) :
        timer_(GetAsioIoContext(loop)) {
}

void Timer::Cancel() {
        timer_.cancel();
}

SignalHandler::SignalHandler(EventLoop &loop) :
        signal_set_ {GetAsioIoContext(loop)} {};

void SignalHandler::Cancel() {
        signal_set_.cancel();
}

error::Error SignalHandler::RegisterHandler(const SignalSet &set, SignalHandlerFn handler_fn) {
        signal_set_.clear();
        for (auto sig_num : set) {
                boost::system::error_code ec;
                signal_set_.add(sig_num, ec);
                if (ec) {
                        return error::Error(
                                ec.default_error_condition(),
                                "Could not add signal " + std::to_string(sig_num) + " to signal set");
                }
        }

        class SignalHandlerFunctor {
        public:
                asio::signal_set &sig_set;
                SignalHandlerFn handler_fn;

                void operator()(const boost::system::error_code &ec, int signal_number) {
                        if (ec) {
                                if (ec == boost::asio::error::operation_aborted) {
                                        // All handlers are called with this error when the signal set
                                        // is cancelled.
                                        return;
                                }
                                log::Error("Failure in signal handler: " + ec.message());
                        } else {
                                handler_fn(signal_number);
                        }

                        // in either case, register ourselves again because
                        // asio::signal_set::async_wait() is a one-off thing
                        sig_set.async_wait(*this);
                }
        };

        SignalHandlerFunctor fctor {signal_set_, handler_fn};
        signal_set_.async_wait(fctor);

        // Unfortunately, asio::signal_set::async_wait() doesn't return anything so
        // we have no chance to propagate any error here (wonder what they do if
        // they get an error from sigaction() or whatever they use
        // internally). Other implementations may have better options, though.
        return error::NoError;
}

} // namespace events
} // namespace common
} // namespace mender

1	// Copyright 2023 Northern.tech AS
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	#include <common/events.hpp>
16
17	#include <boost/asio.hpp>
18
19	#include <common/error.hpp>
20	#include <common/log.hpp>
21
22	namespace mender {
23	namespace common {
24	namespace events {
25
26	namespace asio = boost::asio;
27	namespace error = mender::common::error;
28	namespace log = mender::common::log;
29
30	void EventLoop::Run() {	692✔
31	bool stopped = ctx_.stopped();	692✔
32	if (stopped) {	692✔
33	ctx_.restart();	168✔
34	}
35	ctx_.run();	692✔
36	if (!stopped) {	692✔
37	// For recursive invocations. If we were originally running, but we stopped and
38	// exited this level, then keep the running state of the previous recursive level.
39	ctx_.restart();	524✔
40	}
41	}	692✔
42
43	void EventLoop::Stop() {	689✔
44	ctx_.stop();	689✔
45	}	689✔
46
47	void EventLoop::Post(std::function<void()> func) {	3,443✔
48	ctx_.post(func);	3,443✔
49	}	3,443✔
50
51	Timer::Timer(EventLoop &loop) :	979✔
52	timer_(GetAsioIoContext(loop)) {	979✔
53	}	979✔
54
55	void Timer::Cancel() {	1,077✔
56	timer_.cancel();	1,077✔
57	}	1,077✔
58
59	SignalHandler::SignalHandler(EventLoop &loop) :	×
60	signal_set_ {GetAsioIoContext(loop)} {};	×
61
62	void SignalHandler::Cancel() {	146✔
63	signal_set_.cancel();	146✔
64	}	146✔
65
66	error::Error SignalHandler::RegisterHandler(const SignalSet &set, SignalHandlerFn handler_fn) {	146✔
67	signal_set_.clear();	146✔
68	for (auto sig_num : set) {	390✔
69	boost::system::error_code ec;	244✔
70	signal_set_.add(sig_num, ec);	244✔
71	if (ec) {	244✔
72	return error::Error(
73	ec.default_error_condition(),	×
74	"Could not add signal " + std::to_string(sig_num) + " to signal set");	×
75	}
76	}
77
78	class SignalHandlerFunctor {
79	public:
80	asio::signal_set &sig_set;
81	SignalHandlerFn handler_fn;
82
83	void operator()(const boost::system::error_code &ec, int signal_number) {	8✔
84	if (ec) {	8✔
85	if (ec == boost::asio::error::operation_aborted) {	4✔
86	// All handlers are called with this error when the signal set
87	// is cancelled.
88	return;	4✔
89	}
90	log::Error("Failure in signal handler: " + ec.message());	×
91	} else {
92	handler_fn(signal_number);	4✔
93	}
94
95	// in either case, register ourselves again because
96	// asio::signal_set::async_wait() is a one-off thing
97	sig_set.async_wait(*this);	4✔
98	}
99	};
100
101	SignalHandlerFunctor fctor {signal_set_, handler_fn};	292✔
102	signal_set_.async_wait(fctor);	146✔
103
104	// Unfortunately, asio::signal_set::async_wait() doesn't return anything so
105	// we have no chance to propagate any error here (wonder what they do if
106	// they get an error from sigaction() or whatever they use
107	// internally). Other implementations may have better options, though.
108	return error::NoError;	146✔
109	}
110
111	} // namespace events
112	} // namespace common
113	} // namespace mender

mendersoftware / mender / 1001210836

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