openclaw/deskflow
1
0
Fork 0
Code Issues Pull Requests Actions 17 Packages Projects Releases Wiki Activity

refactor: make ESignal an enum Class IArchMultiThread::ThreadSignal, conform ThreadSignal items to naming conventions

Browse Source
This commit is contained in:
sithlord48
2025-06-30 17:25:35 -04:00
committed by Chris Rizzitello
parent 1692bec7e6
commit cbbfd495e3
8 changed files with 54 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/lib/arch/IArchMultithread.h
View File

@ -69,16 +69,16 @@ public:
Not all platforms support all signals. Unsupported signals are
ignored.
*/
enum ESignal
enum class ThreadSignal : uint8_t
{
kINTERRUPT, //!< Interrupt (e.g. Ctrl+C)
kTERMINATE, //!< Terminate (e.g. Ctrl+Break)
kHANGUP, //!< Hangup (SIGHUP)
kUSER, //!< User (SIGUSR2)
kNUM_SIGNALS
Interrupt, //!< Interrupt (e.g. Ctrl+C)
Terminate, //!< Terminate (e.g. Ctrl+Break)
Hangup, //!< Hangup (SIGHUP)
User, //!< User (SIGUSR2)
MaxSignals //!< Number of differnt signals
};
//! Type of signal handler function
using SignalFunc = void (*)(ESignal, void *userData);
using SignalFunc = void (*)(ThreadSignal, void *userData);
//! @name manipulators
//@{
@ -249,15 +249,15 @@ public:
Sets the function to call on receipt of an external interrupt.
By default and when \p func is nullptr, the main thread is cancelled.
*/
virtual void setSignalHandler(ESignal, SignalFunc func, void *userData) = 0;
virtual void setSignalHandler(ThreadSignal, SignalFunc func, void *userData) = 0;
//! Invoke the signal handler
/*!
Invokes the signal handler for \p signal, if any. If no handler
cancels the main thread for \c kINTERRUPT and \c kTERMINATE and
cancels the main thread for \c ThreadSignal::Interrupt and \c ThreadSignal::Terminate and
ignores the call otherwise.
*/
virtual void raiseSignal(ESignal signal) = 0;
virtual void raiseSignal(ThreadSignal signal) = 0;
//@}
};

29
src/lib/arch/unix/ArchMultithreadPosix.cpp
View File

@ -61,7 +61,7 @@ ArchMultithreadPosix::ArchMultithreadPosix()
s_instance = this;
// no signal handlers
for (size_t i = 0; i < kNUM_SIGNALS; ++i) {
for (size_t i = 0; i < static_cast<size_t>(ThreadSignal::MaxSignals); ++i) {
m_signalFunc[i] = nullptr;
m_signalUserData[i] = nullptr;
}
@ -467,20 +467,24 @@ IArchMultithread::ThreadID ArchMultithreadPosix::getIDOfThread(ArchThread thread
return thread->m_id;
}
void ArchMultithreadPosix::setSignalHandler(ESignal signal, SignalFunc func, void *userData)
void ArchMultithreadPosix::setSignalHandler(ThreadSignal signal, SignalFunc func, void *userData)
{
std::scoped_lock lock{m_threadMutex};
m_signalFunc[signal] = func;
m_signalUserData[signal] = userData;
const auto index = static_cast<int>(signal);
m_signalFunc[index] = func;
m_signalUserData[index] = userData;
}
void ArchMultithreadPosix::raiseSignal(ESignal signal)
void ArchMultithreadPosix::raiseSignal(ThreadSignal signal)
{
using enum ThreadSignal;
std::scoped_lock lock{m_threadMutex};
if (m_signalFunc[signal] != nullptr) {
m_signalFunc[signal](signal, m_signalUserData[signal]);
const auto index = static_cast<int>(signal);
if (m_signalFunc[index] != nullptr) {
m_signalFunc[index](signal, m_signalUserData[index]);
pthread_kill(m_mainThread->m_thread, SIGWAKEUP);
} else if (signal == kINTERRUPT || signal == kTERMINATE) {
} else if (signal == Interrupt || signal == Terminate) {
ARCH->cancelThread(m_mainThread);
}
}
@ -677,20 +681,21 @@ void *ArchMultithreadPosix::threadSignalHandler(void *)
// if we get here then the signal was raised
switch (signal) {
using enum ThreadSignal;
case SIGINT:
ARCH->raiseSignal(kINTERRUPT);
ARCH->raiseSignal(Interrupt);
break;
case SIGTERM:
ARCH->raiseSignal(kTERMINATE);
ARCH->raiseSignal(Terminate);
break;
case SIGHUP:
ARCH->raiseSignal(kHANGUP);
ARCH->raiseSignal(Hangup);
break;
case SIGUSR2:
ARCH->raiseSignal(kUSER);
ARCH->raiseSignal(User);
break;
default:

8
src/lib/arch/unix/ArchMultithreadPosix.h
View File

@ -76,8 +76,8 @@ public:
bool isExitedThread(ArchThread) override;
void *getResultOfThread(ArchThread) override;
ThreadID getIDOfThread(ArchThread) override;
void setSignalHandler(ESignal, SignalFunc, void *) override;
void raiseSignal(ESignal) override;
void setSignalHandler(ThreadSignal, SignalFunc, void *) override;
void raiseSignal(ThreadSignal) override;
private:
void startSignalHandler();
@ -108,6 +108,6 @@ private:
ThreadID m_nextID = 0;
pthread_t m_signalThread;
SignalFunc m_signalFunc[kNUM_SIGNALS];
void *m_signalUserData[kNUM_SIGNALS];
SignalFunc m_signalFunc[static_cast<int>(ThreadSignal::MaxSignals)];
void *m_signalUserData[static_cast<int>(ThreadSignal::MaxSignals)];
};

19
src/lib/arch/win32/ArchMultithreadWindows.cpp
View File

@ -80,7 +80,7 @@ ArchMultithreadWindows::ArchMultithreadWindows()
s_instance = this;
// no signal handlers
for (size_t i = 0; i < kNUM_SIGNALS; ++i) {
for (size_t i = 0; i < static_cast<size_t>(ThreadSignal::MaxSignals); ++i) {
m_signalFunc[i] = nullptr;
m_signalUserData[i] = nullptr;
}
@ -474,20 +474,23 @@ IArchMultithread::ThreadID ArchMultithreadWindows::getIDOfThread(ArchThread thre
return static_cast<ThreadID>(thread->m_id);
}
void ArchMultithreadWindows::setSignalHandler(ESignal signal, SignalFunc func, void *userData)
void ArchMultithreadWindows::setSignalHandler(ThreadSignal signal, SignalFunc func, void *userData)
{
std::scoped_lock lock{m_threadMutex};
m_signalFunc[signal] = func;
m_signalUserData[signal] = userData;
const auto index = static_cast<int>(signal);
m_signalFunc[index] = func;
m_signalUserData[index] = userData;
}
void ArchMultithreadWindows::raiseSignal(ESignal signal)
void ArchMultithreadWindows::raiseSignal(ThreadSignal signal)
{
using enum IArchMultithread::ThreadSignal;
std::scoped_lock lock{m_threadMutex};
if (m_signalFunc[signal] != nullptr) {
m_signalFunc[signal](signal, m_signalUserData[signal]);
const auto index = static_cast<int>(signal);
if (m_signalFunc[index] != nullptr) {
m_signalFunc[index](signal, m_signalUserData[index]);
ARCH->unblockPollSocket(m_mainThread);
} else if (signal == kINTERRUPT || signal == kTERMINATE) {
} else if (signal == Interrupt || signal == Terminate) {
ARCH->cancelThread(m_mainThread);
}
}

8
src/lib/arch/win32/ArchMultithreadWindows.h
View File

@ -83,8 +83,8 @@ public:
bool isExitedThread(ArchThread) override;
void *getResultOfThread(ArchThread) override;
ThreadID getIDOfThread(ArchThread) override;
void setSignalHandler(ESignal, SignalFunc, void *) override;
void raiseSignal(ESignal) override;
void setSignalHandler(ThreadSignal, SignalFunc, void *) override;
void raiseSignal(ThreadSignal) override;
private:
ArchThreadImpl *find(DWORD id);
@ -109,6 +109,6 @@ private:
ThreadList m_threadList;
ArchThread m_mainThread;
SignalFunc m_signalFunc[kNUM_SIGNALS];
void *m_signalUserData[kNUM_SIGNALS];
SignalFunc m_signalFunc[static_cast<int>(ThreadSignal::MaxSignals)];
void *m_signalUserData[static_cast<int>(ThreadSignal::MaxSignals)];
};

10
src/lib/base/EventQueue.cpp
View File

@ -17,7 +17,7 @@
#include <stdexcept>
// interrupt handler. this just adds a quit event to the queue.
static void interrupt(Arch::ESignal, void *data)
static void interrupt(Arch::ThreadSignal, void *data)
{
auto *events = static_cast<EventQueue *>(data);
events->addEvent(Event(EventTypes::Quit));
@ -29,8 +29,8 @@ static void interrupt(Arch::ESignal, void *data)
EventQueue::EventQueue() : m_readyMutex(new Mutex), m_readyCondVar(new CondVar<bool>(m_readyMutex, false))
{
ARCH->setSignalHandler(Arch::kINTERRUPT, &interrupt, this);
ARCH->setSignalHandler(Arch::kTERMINATE, &interrupt, this);
ARCH->setSignalHandler(Arch::ThreadSignal::Interrupt, &interrupt, this);
ARCH->setSignalHandler(Arch::ThreadSignal::Terminate, &interrupt, this);
m_buffer = std::make_unique<SimpleEventQueueBuffer>();
}
@ -39,8 +39,8 @@ EventQueue::~EventQueue()
delete m_readyCondVar;
delete m_readyMutex;
ARCH->setSignalHandler(Arch::kINTERRUPT, nullptr, nullptr);
ARCH->setSignalHandler(Arch::kTERMINATE, nullptr, nullptr);
ARCH->setSignalHandler(Arch::ThreadSignal::Interrupt, nullptr, nullptr);
ARCH->setSignalHandler(Arch::ThreadSignal::Terminate, nullptr, nullptr);
}
void EventQueue::loop()

4
src/lib/deskflow/ServerApp.cpp
View File

@ -140,7 +140,7 @@ void ServerApp::help()
LOG((CLOG_PRINT "%s", help.str().c_str()));
}
void ServerApp::reloadSignalHandler(Arch::ESignal, void *)
void ServerApp::reloadSignalHandler(Arch::ThreadSignal, void *)
{
IEventQueue *events = App::instance().getEvents();
events->addEvent(Event(EventTypes::ServerAppReloadConfig, events->getSystemTarget()));
@ -608,7 +608,7 @@ int ServerApp::mainLoop()
appUtil().startNode();
// handle hangup signal by reloading the server's configuration
ARCH->setSignalHandler(Arch::kHANGUP, &reloadSignalHandler, nullptr);
ARCH->setSignalHandler(Arch::ThreadSignal::Hangup, &reloadSignalHandler, nullptr);
m_events->addHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget(), [this](const auto &) {
reloadConfig();
});

2
src/lib/deskflow/ServerApp.h
View File

@ -118,7 +118,7 @@ public:
// Static functions
//
static void reloadSignalHandler(Arch::ESignal, void *);
static void reloadSignalHandler(Arch::ThreadSignal, void *);
static ServerApp &instance()
{
return (ServerApp &)App::instance();