X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=968bf425901a02e963176dabe69bd4960e7f36be;hp=204c197e3e4fa60a8cda4602f9d696f670ab2604;hb=ae97a322751547af21a637ead6c75ddc0162869b;hpb=d1b6499b0b848d4287efae89107576548533502c diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 204c197e..968bf425 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -30,8 +30,8 @@ #include #include #include -#include #include +#include #include "syncableobject.h" #include "util.h" @@ -68,7 +68,7 @@ SignalRelay::SignalRelay(SignalProxy* parent, QObject* source) caller(source), _sync(false) { - QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender()), Qt::DirectConnection); + QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender())); } int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { @@ -80,11 +80,17 @@ int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { const QList &argTypes = proxy->argTypes(caller, _id); QVariantList params; int n = argTypes.size(); - for(int i=0; imetaObject()->className()).arg(caller->metaObject()->method(_id).signature()); + qWarning() << " - make sure all your data types are known by the Qt MetaSystem"; + return _id; + } + params.append(QVariant(argTypes[i], _a[i+1])); + } QMultiHash::const_iterator funcIter = sigNames.constFind(_id); while(funcIter != sigNames.constEnd() && funcIter.key() == _id) { - proxy->dispatchSignal(funcIter.value(), params); + proxy->dispatchSignal(SignalProxy::RpcCall, QVariantList() << funcIter.value() << params); funcIter++; } @@ -100,10 +106,10 @@ int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { params.prepend(signature); params.prepend(caller->objectName()); params.prepend(caller->metaObject()->className()); - proxy->dispatchSignal((int)SignalProxy::Sync, params); + proxy->dispatchSignal(SignalProxy::Sync, params); } } - _id -= 1; + _id -= QObject::staticMetaObject.methodCount(); } return _id; } @@ -194,6 +200,12 @@ SignalProxy::~SignalProxy() { QList senders = _relayHash.keys(); foreach(QObject* sender, senders) detachObject(sender); + + // close peer connections + foreach(QIODevice *device, _peerByteCount.keys()) { + device->close(); + delete device; + } } void SignalProxy::setProxyMode(ProxyMode mode) { @@ -215,10 +227,15 @@ SignalProxy::ProxyMode SignalProxy::proxyMode() const { } void SignalProxy::initServer() { + disconnect(&_heartBeatTimer, 0, this, 0); + _heartBeatTimer.stop(); } void SignalProxy::initClient() { attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray, QString, QString))); + connect(&_heartBeatTimer, SIGNAL(timeout()), + this, SLOT(sendHeartBeat())); + _heartBeatTimer.start(60 * 1000); // msecs: one beep per minute } bool SignalProxy::addPeer(QIODevice* iodev) { @@ -268,12 +285,11 @@ void SignalProxy::objectRenamed(QString oldname, QString newname) { return; QVariantList params; - params << className << oldname << newname; - dispatchSignal("__objectRenamed__", params); + params << "__objectRenamed__" << className << oldname << newname; + dispatchSignal(RpcCall, params); } void SignalProxy::objectRenamed(QByteArray classname, QString oldname, QString newname) { - QMutexLocker locker(&slaveMutex); if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) _syncSlave[classname][newname] = _syncSlave[classname].take(oldname); } @@ -338,6 +354,21 @@ const QList &SignalProxy::argTypes(QObject *obj, int methodId) { return _classInfo[obj->metaObject()]->argTypes[methodId]; } +void SignalProxy::setMinArgCount(QObject *obj, int methodId) { + const QMetaObject *meta = obj->metaObject(); + QString signature(meta->method(methodId).signature()); + int minCount = meta->method(methodId).parameterTypes().count() - signature.count("="); + Q_ASSERT(!_classInfo[meta]->minArgCount.contains(methodId)); + _classInfo[meta]->minArgCount[methodId] = minCount; +} + +const int &SignalProxy::minArgCount(QObject *obj, int methodId) { + Q_ASSERT(_classInfo.contains(obj->metaObject())); + if(!_classInfo[obj->metaObject()]->minArgCount.contains(methodId)) + setMinArgCount(obj, methodId); + return _classInfo[obj->metaObject()]->minArgCount[methodId]; +} + void SignalProxy::setMethodName(QObject *obj, int methodId) { const QMetaObject *meta = obj->metaObject(); QByteArray method(::methodName(meta->method(methodId))); @@ -395,12 +426,24 @@ const QHash &SignalProxy::syncMap(SyncableObject *obj) { return _classInfo[obj->metaObject()]->syncMap; } +void SignalProxy::setUpdatedRemotelyId(QObject *obj) { + const QMetaObject *meta = obj->metaObject(); + Q_ASSERT(_classInfo.contains(meta)); + _classInfo[meta]->updatedRemotelyId = meta->indexOfSignal("updatedRemotely()"); +} + +int SignalProxy::updatedRemotelyId(SyncableObject *obj) { + Q_ASSERT(_classInfo.contains(obj->metaObject())); + return _classInfo[obj->metaObject()]->updatedRemotelyId; +} + void SignalProxy::createClassInfo(QObject *obj) { if(_classInfo.contains(obj->metaObject())) return; ClassInfo *classInfo = new ClassInfo(); _classInfo[obj->metaObject()] = classInfo; + setUpdatedRemotelyId(obj); } bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) { @@ -440,7 +483,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()), Qt::DirectConnection); + QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender())); return true; } @@ -462,7 +505,7 @@ void SignalProxy::synchronize(SyncableObject *obj) { 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); + connect(obj, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString))); setInitialized(obj); } else { @@ -486,51 +529,26 @@ void SignalProxy::requestInit(SyncableObject *obj) { QVariantList params; params << obj->metaObject()->className() << obj->objectName(); - dispatchSignal((int)InitRequest, params); + dispatchSignal(InitRequest, params); } void SignalProxy::detachSender() { - // 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) { - QMutexLocker locker(&slaveMutex); - _detachSignals(obj); - _detachSlots(obj); - SyncableObject *syncobj = qobject_cast(obj); - if(syncobj) _stopSync(syncobj); + detachSignals(obj); + detachSlots(obj); + stopSync(static_cast(obj)); } void SignalProxy::detachSignals(QObject* sender) { - QMutexLocker locker(&slaveMutex); - _detachSignals(sender); -} - -void SignalProxy::detachSlots(QObject* receiver) { - QMutexLocker locker(&slaveMutex); - _detachSlots(receiver); -} - -void SignalProxy::stopSync(SyncableObject* obj) { - QMutexLocker locker(&slaveMutex); - _stopSync(obj); -} - -void SignalProxy::_detachSignals(QObject* sender) { if(!_relayHash.contains(sender)) return; _relayHash.take(sender)->deleteLater(); } -void SignalProxy::_detachSlots(QObject* receiver) { +void SignalProxy::detachSlots(QObject* receiver) { SlotHash::iterator slotIter = _attachedSlots.begin(); while(slotIter != _attachedSlots.end()) { if(slotIter.value().first == receiver) { @@ -540,7 +558,7 @@ void SignalProxy::_detachSlots(QObject* receiver) { } } -void SignalProxy::_stopSync(SyncableObject* obj) { +void SignalProxy::stopSync(SyncableObject* obj) { if(_relayHash.contains(obj)) _relayHash[obj]->setSynchronize(false); @@ -548,7 +566,7 @@ void SignalProxy::_stopSync(SyncableObject* obj) { // 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())) { + if(classIter->contains(obj->objectName()) && classIter.value()[obj->objectName()] == obj) { classIter->remove(obj->objectName()); break; } @@ -556,17 +574,17 @@ void SignalProxy::_stopSync(SyncableObject* obj) { } } -void SignalProxy::dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList ¶ms) { +void SignalProxy::dispatchSignal(QIODevice *receiver, const RequestType &requestType, const QVariantList ¶ms) { QVariantList packedFunc; - packedFunc << identifier; + packedFunc << (qint16)requestType; packedFunc << params; writeDataToDevice(receiver, QVariant(packedFunc)); } -void SignalProxy::dispatchSignal(const QVariant &identifier, const QVariantList ¶ms) { +void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) { // yes I know we have a little code duplication here... it's for the sake of performance QVariantList packedFunc; - packedFunc << identifier; + packedFunc << (qint16)requestType; packedFunc << params; foreach(QIODevice* dev, _peerByteCount.keys()) writeDataToDevice(dev, QVariant(packedFunc)); @@ -575,24 +593,31 @@ void SignalProxy::dispatchSignal(const QVariant &identifier, const QVariantList void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFunc) { QVariantList params(packedFunc.toList()); - QVariant call = params.takeFirst(); - 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); + if(params.isEmpty()) { + qWarning() << "SignalProxy::receivePeerSignal(): received incompatible Data:" << packedFunc; + return; + } + + int callType = params.takeFirst().value(); - switch(call.toInt()) { + switch(callType) { + case RpcCall: + if(params.empty()) { + qWarning() << "SignalProxy::receivePeerSignal(): received empty RPC-Call"; + return; + } else { + return handleSignal(params.takeFirst().toByteArray(), params); + } case Sync: return handleSync(params); case InitRequest: return handleInitRequest(sender, params); case InitData: return handleInitData(sender, params); + case HeartBeat: + return; default: - qWarning() << "received undefined CallType" << call.toInt(); + qWarning() << "SignalProxy::receivePeerSignal(): received undefined CallType" << callType << params; return; } } @@ -608,14 +633,14 @@ void SignalProxy::handleSync(QVariantList params) { QByteArray signal = params.takeFirst().toByteArray(); if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) { - qWarning() << QString("no registered receiver for sync call: %s::%s (objectName=\"%s\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) + qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) << params; return; } SyncableObject *receiver = _syncSlave[className][objectName]; 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) + qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) << params; return; } @@ -625,7 +650,7 @@ void SignalProxy::handleSync(QVariantList params) { qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData()); return; } - QMetaObject::invokeMethod(receiver, "updatedRemotely"); + invokeSlot(receiver, updatedRemotelyId(receiver)); } void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList ¶ms) { @@ -657,13 +682,13 @@ void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList ¶m << obj->objectName() << initData(obj); - dispatchSignal(sender, (int)InitData, params_); + dispatchSignal(sender, InitData, params_); } void SignalProxy::handleInitData(QIODevice *sender, const QVariantList ¶ms) { Q_UNUSED(sender) if(params.count() != 3) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:" + qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:" << params; return; } @@ -673,13 +698,13 @@ void SignalProxy::handleInitData(QIODevice *sender, const QVariantList ¶ms) QVariantMap propertyMap(params[2].toMap()); if(!_syncSlave.contains(className)) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" + qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:" << className; return; } if(!_syncSlave[className].contains(objectName)) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:" + qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:" << className << objectName; return; } @@ -702,11 +727,46 @@ void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList &p } bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms) { - int numParams = argTypes(receiver, methodId).count(); - QGenericArgument args[9]; - for(int i = 0; i < numParams; i++) - args[i] = QGenericArgument(params[i].typeName(), params[i].constData()); - return QMetaObject::invokeMethod(receiver, methodName(receiver, methodId), args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]); + const QList args = argTypes(receiver, methodId); + const int numArgs = params.count() < args.count() + ? params.count() + : args.count(); + + if(minArgCount(receiver, methodId) > params.count()) { + qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << methodName(receiver, methodId); + return false; + } + + void *_a[] = {0, // return type + 0, 0, 0, 0 , 0, // and 10 args - that's the max size qt can handle with signals and slots + 0, 0, 0, 0 , 0}; + // check for argument compatibility and build params array + for(int i = 0; i < numArgs; i++) { + if(!params[i].isValid()) { + qWarning() << "SignalProxy::invokeSlot(): received invalid data for argument number" << i << "of method" << QString("%1::%2()").arg(receiver->metaObject()->className()).arg(receiver->metaObject()->method(methodId).signature()); + qWarning() << " - make sure all your data types are known by the Qt MetaSystem"; + return false; + } + if(args[i] != QMetaType::type(params[i].typeName())) { + qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << methodName(receiver, methodId); + return false; + } + _a[i+1] = const_cast(params[i].constData()); + } + + + Qt::ConnectionType type = QThread::currentThread() == receiver->thread() + ? Qt::DirectConnection + : Qt::QueuedConnection; + + if (type == Qt::DirectConnection) { + return receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0; + } else { + qWarning() << "Queued Connections are not implemented yet"; + // not to self: qmetaobject.cpp:990 ff + return false; + } + } void SignalProxy::dataAvailable() { @@ -792,6 +852,11 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties return; obj->fromVariantMap(properties); setInitialized(obj); + invokeSlot(obj, updatedRemotelyId(obj)); +} + +void SignalProxy::sendHeartBeat() { + dispatchSignal(SignalProxy::HeartBeat, QVariantList()); } void SignalProxy::dumpProxyStats() {