X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=a6e16faab47475b642b6151b7d6125d7eee90b79;hp=ad9f36a1e12497f2a5e4040de6e61b81a2bda068;hb=fe1fec5e5f0799e03f6a3473dc56511bc00f26eb;hpb=836534302ea576791dc5cc01918dd4c5abd61878 diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index ad9f36a1..a6e16faa 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -5,7 +5,7 @@ * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * - * (at your option) any later version. * + * (at your option) version 3. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * @@ -29,6 +29,7 @@ #include #include #include +#include #include #include "util.h" @@ -62,7 +63,7 @@ SignalRelay::SignalRelay(SignalProxy* parent, QObject* source) caller(source), _sync(false) { - QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender())); + QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender()), Qt::DirectConnection); } int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { @@ -327,7 +328,6 @@ const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) { void SignalProxy::setSyncMap(QObject *obj) { const QMetaObject *meta = obj->metaObject(); - QHash syncMap; QList slotIndexes; @@ -410,7 +410,7 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha _attachedSlots.insert(funcName, qMakePair(recv, methodId)); QObject::disconnect(recv, SIGNAL(destroyed()), this, SLOT(detachSender())); - QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender())); + QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()), Qt::DirectConnection); return true; } @@ -472,30 +472,37 @@ void SignalProxy::requestInit(QObject *obj) { } void SignalProxy::detachSender() { - // this is a slot so we can bypass the QueuedConnection - // and if someone is forcing direct connection in a multithreaded environment he's just nuts... - _detachSignals(sender()); - _detachSlots(sender()); + // this is a private slot. the reason for that is, that we enfoce Qt::DirectConnection. + // the result is, that we can be sure, that a registered receiver is removed immediately when it's destroyed. + // since we're guarding the the internal datastructures with mutexes this means, + // that the object destruction is deffered until we're finished delivering our sync/init/whatever request. + // all in all: thread safety! *sigh* + detachObject(sender()); } // detachObject/Signals/Slots() can be called as a result of an incoming call // this might destroy our the iterator used for delivery // thus we wrap the actual disconnection by using QueuedConnections void SignalProxy::detachObject(QObject* obj) { - detachSignals(obj); - detachSlots(obj); + QMutexLocker locker(&slaveMutex); + _detachSignals(obj); + _detachSlots(obj); + _stopSync(obj); } void SignalProxy::detachSignals(QObject* sender) { - QMetaObject::invokeMethod(this, "_detachSignals", - Qt::QueuedConnection, - Q_ARG(QObject*, sender)); + QMutexLocker locker(&slaveMutex); + _detachSignals(sender); } void SignalProxy::detachSlots(QObject* receiver) { - QMetaObject::invokeMethod(this, "_detachSlots", - Qt::QueuedConnection, - Q_ARG(QObject*, receiver)); + QMutexLocker locker(&slaveMutex); + _detachSlots(receiver); +} + +void SignalProxy::stopSync(QObject* obj) { + QMutexLocker locker(&slaveMutex); + _stopSync(obj); } void SignalProxy::_detachSignals(QObject* sender) { @@ -514,6 +521,22 @@ void SignalProxy::_detachSlots(QObject* receiver) { } } +void SignalProxy::_stopSync(QObject* obj) { + if(_relayHash.contains(obj)) + _relayHash[obj]->setSynchronize(false); + + // we can't use a className here, since it might be effed up, if we receive the call as a result of a decon + // gladly the objectName() is still valid. So we have only to iterate over the classes not each instance! *sigh* + QHash::iterator classIter = _syncSlave.begin(); + while(classIter != _syncSlave.end()) { + if(classIter->contains(obj->objectName())) { + classIter->remove(obj->objectName()); + break; + } + classIter++; + } +} + void SignalProxy::dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList ¶ms) { QVariantList packedFunc; packedFunc << identifier; @@ -533,6 +556,11 @@ void SignalProxy::dispatchSignal(const QVariant &identifier, const QVariantList void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFunc) { QVariantList params(packedFunc.toList()); + // well yes we are locking code here and not only data. + // otherwise each handler would have to lock the data anyway. this leaves us on the safe side + // unable to forget a lock + QMutexLocker locker(&slaveMutex); + QVariant call = params.takeFirst(); if(call.type() != QVariant::Int) return handleSignal(call.toByteArray(), params); @@ -556,7 +584,7 @@ void SignalProxy::handleSync(QVariantList params) { return; } - QByteArray className =params.takeFirst().toByteArray(); + QByteArray className = params.takeFirst().toByteArray(); QString objectName = params.takeFirst().toString(); int signalId = params.takeFirst().toInt(); @@ -567,8 +595,17 @@ void SignalProxy::handleSync(QVariantList params) { QObject *receiver = _syncSlave[className][objectName]; if(!syncMap(receiver).contains(signalId)) { - qWarning() << "received Sync Call with invalid SignalId" << className << objectName << signalId; - } + const QMetaObject *meta = receiver->metaObject(); + QString signalName; + if(signalId < meta->methodCount()) + signalName = QString(meta->method(signalId).signature()); + else + signalName = QString::number(signalId); + + qWarning() << "received Sync Call for Object" << receiver + << "- no matching Slot for Signal:" << signalName; + return; + } int slotId = syncMap(receiver)[signalId]; if(!invokeSlot(receiver, slotId, params)) qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData()); @@ -811,4 +848,14 @@ void SignalProxy::dumpProxyStats() { qDebug() << "number of Classes cached:" << _classInfo.count(); } +void SignalProxy::dumpSyncMap(QObject *object) { + const QMetaObject *meta = object->metaObject(); + qDebug() << "SignalProxy: SyncMap for Class" << meta->className(); + QHash syncMap_ = syncMap(object); + QHash::const_iterator iter = syncMap_.constBegin(); + while(iter != syncMap_.constEnd()) { + qDebug() << iter.key() << meta->method(iter.key()).signature() << "-->" << iter.value() << meta->method(iter.value()).signature(); + iter++; + } +}