StarMirror/qTox
1
0
Fork 0
mirror of https://github.com/qTox/qTox.git synced 2024-03-22 14:00:36 +08:00
Code Issues Projects Releases Wiki Activity

refactor(ipc): cleanup and improve debug messages

Browse Source
This commit is contained in:
sudden6 2018-12-18 23:37:59 +01:00
parent 49507d76d8
commit 5afa78cd4d
No known key found for this signature in database
GPG Key ID: 279509B499E032B9
1 changed files with 97 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/ipc.cpp
View File

@ -82,14 +82,15 @@ IPC::IPC(uint32_t profileId)
IPC::~IPC()
{
if (globalMemory.lock()) {
if (!globalMemory.lock()) {
qWarning() << "Failed to lock in ~IPC";
return;
}
if (isCurrentOwnerNoLock()) {
global()->globalId = 0;
}
globalMemory.unlock();
} else {
qWarning() << "Failed to lock in ~IPC";
}
}
/**
@ -97,26 +98,33 @@ IPC::~IPC()
* @param name Name to set in IPC event.
* @param data Data to set in IPC event (default QByteArray()).
* @param dest Settings::getCurrentProfileId() or 0 (main instance, default).
* @return Time the event finished.
* @return Time the event finished or 0 on error.
*/
time_t IPC::postEvent(const QString& name, const QByteArray& data, uint32_t dest)
{
QByteArray binName = name.toUtf8();
if (binName.length() > (int32_t)sizeof(IPCEvent::name))
if (binName.length() > (int32_t)sizeof(IPCEvent::name)) {
return 0;
}
if (data.length() > (int32_t)sizeof(IPCEvent::data))
if (data.length() > (int32_t)sizeof(IPCEvent::data)) {
return 0;
}
if (!globalMemory.lock()) {
qDebug() << "Failed to lock in postEvent()";
return 0;
}
if (globalMemory.lock()) {
IPCEvent* evt = nullptr;
IPCMemory* mem = global();
time_t result = 0;
for (uint32_t i = 0; !evt && i < EVENT_QUEUE_SIZE; ++i) {
if (mem->events[i].posted == 0)
if (mem->events[i].posted == 0) {
evt = &mem->events[i];
}
}
if (evt) {
memset(evt, 0, sizeof(IPCEvent));
@ -127,12 +135,9 @@ time_t IPC::postEvent(const QString& name, const QByteArray& data, uint32_t dest
evt->sender = getpid();
qDebug() << "postEvent " << name << "to" << dest;
}
globalMemory.unlock();
return result;
} else
qDebug() << "Failed to lock in postEvent()";
return 0;
}
bool IPC::isCurrentOwner()
@ -159,7 +164,10 @@ void IPC::registerEventHandler(const QString& name, IPCEventHandler handler)
bool IPC::isEventAccepted(time_t time)
{
bool result = false;
if (globalMemory.lock()) {
if (!globalMemory.lock()) {
return result;
}
if (difftime(global()->lastProcessed, time) > 0) {
IPCMemory* mem = global();
for (uint32_t i = 0; i < EVENT_QUEUE_SIZE; ++i) {
@ -170,7 +178,7 @@ bool IPC::isEventAccepted(time_t time)
}
}
globalMemory.unlock();
}
return result;
}
@ -181,8 +189,9 @@ bool IPC::waitUntilAccepted(time_t postTime, int32_t timeout /*=-1*/)
forever
{
result = isEventAccepted(postTime);
if (result || (timeout > 0 && difftime(time(nullptr), start) >= timeout))
if (result || (timeout > 0 && difftime(time(nullptr), start) >= timeout)) {
break;
}
qApp->processEvents();
QThread::msleep(0);
@ -214,13 +223,15 @@ IPC::IPCEvent* IPC::fetchEvent()
// and events that were processed and EVENT_GC_TIMEOUT passed after
// so sending instance has time to react to those events.
if ((evt->processed && difftime(time(nullptr), evt->processed) > EVENT_GC_TIMEOUT)
|| (!evt->processed && difftime(time(nullptr), evt->posted) > EVENT_GC_TIMEOUT))
|| (!evt->processed && difftime(time(nullptr), evt->posted) > EVENT_GC_TIMEOUT)) {
memset(evt, 0, sizeof(IPCEvent));
}
if (evt->posted && !evt->processed && evt->sender != getpid()
&& (evt->dest == profileId || (evt->dest == 0 && isCurrentOwnerNoLock())))
&& (evt->dest == profileId || (evt->dest == 0 && isCurrentOwnerNoLock()))) {
return evt;
}
}
return nullptr;
}
@ -228,19 +239,24 @@ IPC::IPCEvent* IPC::fetchEvent()
bool IPC::runEventHandler(IPCEventHandler handler, const QByteArray& arg)
{
bool result = false;
if (QThread::currentThread() == qApp->thread())
if (QThread::currentThread() == qApp->thread()) {
result = handler(arg);
else
} else {
QMetaObject::invokeMethod(this, "runEventHandler", Qt::BlockingQueuedConnection,
Q_RETURN_ARG(bool, result), Q_ARG(IPCEventHandler, handler),
Q_ARG(const QByteArray&, arg));
}
return result;
}
void IPC::processEvents()
{
if (globalMemory.lock()) {
if (!globalMemory.lock()) {
timer.start();
return;
}
IPCMemory* mem = global();
if (mem->globalId == globalId) {
@ -264,22 +280,26 @@ void IPC::processEvents()
QString name = QString::fromUtf8(evt->name);
auto it = eventHandlers.find(name);
if (it != eventHandlers.end()) {
qDebug() << "Processing event: " << name << ":" << evt->posted << "=" << evt->accepted;
evt->accepted = runEventHandler(it.value(), evt->data);
qDebug() << "Processed event:" << name << "posted:" << evt->posted
<< "accepted:" << evt->accepted;
if (evt->dest == 0) {
// Global events should be processed only by instance that accepted event.
// Otherwise global
// event would be consumed by very first instance that gets to check it.
if (evt->accepted)
if (evt->accepted) {
evt->processed = time(nullptr);
}
} else {
evt->processed = time(nullptr);
}
} else {
qDebug() << "Received event:" << name << "without handler";
qDebug() << "Available handlers:" << eventHandlers.keys();
}
}
globalMemory.unlock();
}
timer.start();
}