X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=0af4fdc070452080946f368471e237bb0f1775bc;hp=904768d5843b7d88a611d9731b454085c976f705;hb=17a902604b2631d1165fb8c7af65e064e37a49d7;hpb=924e2c01204da172a071d34485936b379372e497 diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 904768d5..0af4fdc0 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" @@ -50,6 +51,8 @@ public: int sigCount() const; private: + bool isSyncMethod(int i); + SignalProxy* proxy; QObject* caller; QMultiHash sigNames; @@ -62,7 +65,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) { @@ -81,13 +84,17 @@ int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { proxy->dispatchSignal(funcIter.value(), params); funcIter++; } - if(synchronize() && proxy->syncMap(caller).contains(_id)) { + + // dispatch Sync Signal if necessary + QByteArray signature(caller->metaObject()->method(_id).signature()); + if(synchronize() && proxy->syncMap(caller).contains(signature)) { // qDebug() << "__SYNC__ >>>" // << caller->metaObject()->className() // << caller->objectName() // << proxy->methodName(caller, _id) // << params; - params.prepend(QVariant(_id)); + // params.prepend(QVariant(_id)); + params.prepend(signature); params.prepend(caller->objectName()); params.prepend(caller->metaObject()->className()); proxy->dispatchSignal((int)SignalProxy::Sync, params); @@ -99,21 +106,37 @@ int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { } void SignalRelay::setSynchronize(bool sync) { - QHash::const_iterator iter = proxy->syncMap(caller).constBegin(); + const QMetaObject *meta = caller->metaObject(); if(!_sync && sync) { - while(iter != proxy->syncMap(caller).constEnd()) { - QMetaObject::connect(caller, iter.key(), this, QObject::staticMetaObject.methodCount() + iter.key()); - iter++; + // enable Sync + for(int i = 0; i < meta->methodCount(); i++ ) { + if(isSyncMethod(i)) + QMetaObject::connect(caller, i, this, QObject::staticMetaObject.methodCount() + i); } } else if (_sync && !sync) { - while(iter != proxy->syncMap(caller).constEnd()) { - QMetaObject::disconnect(caller, iter.key(), this, QObject::staticMetaObject.methodCount() + iter.key()); - iter++; + // disable Sync + for(int i = 0; i < meta->methodCount(); i++ ) { + if(isSyncMethod(i)) + QMetaObject::disconnect(caller, i, this, QObject::staticMetaObject.methodCount() + i); } } _sync = sync; } +bool SignalRelay::isSyncMethod(int i) { + QByteArray signature = caller->metaObject()->method(i).signature(); + if(!proxy->syncMap(caller).contains(signature)) + return false; + + if(proxy->proxyMode() == SignalProxy::Server && !signature.startsWith("request")) + return true; + + if(proxy->proxyMode() == SignalProxy::Client && signature.startsWith("request")) + return true; + + return false; +} + bool SignalRelay::synchronize() const { return _sync; } @@ -246,7 +269,8 @@ void SignalProxy::objectRenamed(QString oldname, QString newname) { } void SignalProxy::objectRenamed(QByteArray classname, QString oldname, QString newname) { - if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname)) + QMutexLocker locker(&slaveMutex); + if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) _syncSlave[classname][newname] = _syncSlave[classname].take(oldname); } @@ -327,8 +351,7 @@ const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) { void SignalProxy::setSyncMap(QObject *obj) { const QMetaObject *meta = obj->metaObject(); - - QHash syncMap; + QHash syncMap; QList slotIndexes; for(int i = 0; i < meta->methodCount(); i++) { @@ -353,7 +376,7 @@ void SignalProxy::setSyncMap(QObject *obj) { } if(matchIdx != -1) { slotIndexes.removeAt(slotIndexes.indexOf(matchIdx)); - syncMap[signalIdx] = matchIdx; + syncMap[QByteArray(signal.signature())] = matchIdx; } } @@ -361,7 +384,7 @@ void SignalProxy::setSyncMap(QObject *obj) { _classInfo[meta]->syncMap = syncMap; } -const QHash &SignalProxy::syncMap(QObject *obj) { +const QHash &SignalProxy::syncMap(QObject *obj) { Q_ASSERT(_classInfo.contains(obj->metaObject())); if(_classInfo[obj->metaObject()]->syncMap.isEmpty()) setSyncMap(obj); @@ -410,44 +433,34 @@ 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; } void SignalProxy::synchronize(QObject *obj) { - if(proxyMode() == Server) - return synchronizeAsMaster(obj); - else - return synchronizeAsSlave(obj); -} - -void SignalProxy::synchronizeAsMaster(QObject *sender) { - createClassInfo(sender); + createClassInfo(obj); + // attaching all the Signals SignalRelay* relay; - if(_relayHash.contains(sender)) - relay = _relayHash[sender]; + if(_relayHash.contains(obj)) + relay = _relayHash[obj]; else - relay = _relayHash[sender] = new SignalRelay(this, sender); + relay = _relayHash[obj] = new SignalRelay(this, obj); relay->setSynchronize(true); - if(sender->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1) - connect(sender, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString))); - - QByteArray className(sender->metaObject()->className()); - _syncSlave[className][sender->objectName()] = sender; + // attaching as slave to receive sync Calls + QByteArray className(obj->metaObject()->className()); + _syncSlave[className][obj->objectName()] = obj; - setInitialized(sender); -} - -void SignalProxy::synchronizeAsSlave(QObject *receiver) { - QByteArray className(receiver->metaObject()->className()); - _syncSlave[className][receiver->objectName()] = receiver; - - createClassInfo(receiver); + if(proxyMode() == Server) { + if(obj->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1) + connect(obj, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)), Qt::DirectConnection); - requestInit(receiver); + setInitialized(obj); + } else { + requestInit(obj); + } } void SignalProxy::setInitialized(QObject *obj) { @@ -472,30 +485,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 +534,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; @@ -537,6 +573,11 @@ void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFun if(call.type() != QVariant::Int) return handleSignal(call.toByteArray(), params); + // 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); + switch(call.toInt()) { case Sync: return handleSync(params); @@ -556,20 +597,24 @@ 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(); + QByteArray signal = params.takeFirst().toByteArray(); if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) { - qWarning() << "no registered receiver:" << className << objectName << "for Sync call" << signalId << params; + qWarning() << QString("no registered receiver for sync call: %s::%s (objectName=\"%s\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) + << params; return; } QObject *receiver = _syncSlave[className][objectName]; - if(!syncMap(receiver).contains(signalId)) { - qWarning() << "received Sync Call with invalid SignalId" << className << objectName << signalId; + if(!syncMap(receiver).contains(signal)) { + qWarning() << QString("no matching slot for sync call: %s::%s (objectName=\"%s\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) + << params; + return; } - int slotId = syncMap(receiver)[signalId]; + + int slotId = syncMap(receiver)[signal]; if(!invokeSlot(receiver, slotId, params)) qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData()); } @@ -583,7 +628,7 @@ void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList ¶m QByteArray className(params[0].toByteArray()); QString objectName(params[1].toString()); - + if(!_syncSlave.contains(className)) { qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" << className; @@ -595,7 +640,7 @@ void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList ¶m << className << objectName; return; } - + QObject *obj = _syncSlave[className][objectName]; QVariantList params_; @@ -811,4 +856,20 @@ 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() << "-->" << iter.value() << meta->method(iter.value()).signature(); + iter++; + } +// 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++; +// } +}