X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=794e878a1121e271a3ad71ea3ba7a7246d54ef5e;hp=91ffae9f4b0706cbfbfc7c65cc2c7dcc4fd14bbb;hb=1ed8c48b0e7d309e1a92c905a19fcb7128b73d3d;hpb=bfe9db08aabd456aa66ae9a505fa0a52fdade3fd diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 91ffae9f..794e878a 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -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) { @@ -252,35 +269,9 @@ bool SignalProxy::addPeer(QIODevice* iodev) { return true; } -void SignalProxy::removePeerBySender() { - // OK we're brutal here... but since it's a private slot we know what we've got connected to it... - QIODevice *ioDev = (QIODevice *)(sender()); - removePeer(ioDev); - qDebug() << "Client disconnected."; -} - -void SignalProxy::objectRenamed(QString oldname, QString newname) { - const QMetaObject *meta = sender()->metaObject(); - const QByteArray className(meta->className()); - objectRenamed(className, oldname, newname); - - if(proxyMode() == Client) - return; - - QVariantList params; - params << className << oldname << newname; - dispatchSignal("__objectRenamed__", params); -} - -void SignalProxy::objectRenamed(QByteArray classname, QString oldname, QString newname) { - if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) - _syncSlave[classname][newname] = _syncSlave[classname].take(oldname); -} - - void SignalProxy::removePeer(QIODevice* iodev) { if(_peerByteCount.isEmpty()) { - qWarning() << "SignalProxy: No peers in use!"; + qWarning() << "SignalProxy::removePeer(): No peers in use!"; return; } @@ -300,15 +291,7 @@ void SignalProxy::removePeer(QIODevice* iodev) { qWarning() << "SignalProxy: unknown QIODevice" << iodev; return; } - - // take a last gasp - while(true) { - QVariant var; - if(readDataFromDevice(iodev, _peerByteCount[iodev], var)) - receivePeerSignal(iodev, var); - else - break; - } + _peerByteCount.remove(iodev); disconnect(iodev, 0, this, 0); @@ -318,6 +301,33 @@ void SignalProxy::removePeer(QIODevice* iodev) { emit disconnected(); } +void SignalProxy::removePeerBySender() { + // OK we're brutal here... but since it's a private slot we know what we've got connected to it... + QIODevice *ioDev = (QIODevice *)(sender()); + removePeer(ioDev); + qDebug() << "Client disconnected."; +} + +void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) { + const QMetaObject *meta = sender()->metaObject(); + const QByteArray className(meta->className()); + objectRenamed(className, oldname, newname); + + if(proxyMode() == Client) + return; + + QVariantList params; + params << "__objectRenamed__" << className << newname << oldname; + dispatchSignal(RpcCall, params); +} + +void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname) { + if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) { + SyncableObject *obj = _syncSlave[classname][newname] = _syncSlave[classname].take(oldname); + requestInit(obj); + } +} + void SignalProxy::setArgTypes(QObject* obj, int methodId) { const QMetaObject *meta = obj->metaObject(); QList p = meta->method(methodId).parameterTypes(); @@ -487,9 +497,7 @@ void SignalProxy::synchronize(SyncableObject *obj) { _syncSlave[className][obj->objectName()] = 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))); - + connect(obj, SIGNAL(objectRenamed(QString, QString)), this, SLOT(objectRenamed(QString, QString))); setInitialized(obj); } else { requestInit(obj); @@ -512,7 +520,7 @@ void SignalProxy::requestInit(SyncableObject *obj) { QVariantList params; params << obj->metaObject()->className() << obj->objectName(); - dispatchSignal((int)InitRequest, params); + dispatchSignal(InitRequest, params); } void SignalProxy::detachSender() { @@ -549,7 +557,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; } @@ -557,17 +565,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)); @@ -576,19 +584,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); + 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; } } @@ -604,14 +624,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; } @@ -653,7 +673,7 @@ 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) { @@ -703,15 +723,21 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList ? params.count() : args.count(); - if(minArgCount(receiver, methodId) < params.count()) { + if(minArgCount(receiver, methodId) > params.count()) { qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << methodName(receiver, methodId); return false; } - - void *_a[numArgs+1]; - _a[0] = 0; + + 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; @@ -820,6 +846,10 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties invokeSlot(obj, updatedRemotelyId(obj)); } +void SignalProxy::sendHeartBeat() { + dispatchSignal(SignalProxy::HeartBeat, QVariantList()); +} + void SignalProxy::dumpProxyStats() { QString mode; if(proxyMode() == Server)