X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=c551c24697f7a63a23a9ae63b1076485f7441f5b;hp=1b05ab43fb786bcf4465feaa505de4c7e6e3a846;hb=a5dfcc8ecf8b81025d24b3c5c816169e3e030ea4;hpb=f24b79010368ac773923d29187c15c33aea69bc9 diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 1b05ab43..c551c246 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -34,10 +34,28 @@ #include #include #include +#include +#include #include "syncableobject.h" #include "util.h" +// ================================================== +// PeerSignalEvent +// ================================================== +class PeerSignalEvent : public QEvent { +public: + PeerSignalEvent(SignalProxy *sender, SignalProxy::RequestType requestType, const QVariantList ¶ms) : QEvent(QEvent::Type(SignalProxy::PeerSignal)), sender(sender), requestType(requestType), params(params) {} + SignalProxy *sender; + SignalProxy::RequestType requestType; + QVariantList params; +}; + +class RemovePeerEvent : public QEvent { +public: + RemovePeerEvent(QObject *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeer)), peer(peer) {} + QObject *peer; +}; // ================================================== // SIGNALRELAY @@ -55,12 +73,12 @@ public: void setSynchronize(bool); bool synchronize() const; - + int sigCount() const; - + private: bool isSyncMethod(int i); - + SignalProxy* proxy; QObject* caller; QMultiHash sigNames; @@ -98,7 +116,7 @@ int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { proxy->dispatchSignal(SignalProxy::RpcCall, QVariantList() << funcIter.value() << params); funcIter++; } - + // dispatch Sync Signal if necessary QByteArray signature(caller->metaObject()->method(_id).signature()); SyncableObject *syncObject = qobject_cast(caller); @@ -150,7 +168,7 @@ bool SignalRelay::isSyncMethod(int i) { QByteArray signature = syncObject->syncMetaObject()->method(i).signature(); if(!proxy->syncMap(syncObject).contains(signature)) return false; - + if(proxy->proxyMode() == SignalProxy::Server && !signature.contains("Requested")) return true; @@ -194,6 +212,26 @@ void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, c dispatchPackedFunc(QVariant(packedFunc)); } +QString SignalProxy::IODevicePeer::address() const { + QAbstractSocket *socket = qobject_cast(_device); + if(socket) + return socket->peerAddress().toString(); + else + return QString(); +} + +void SignalProxy::SignalProxyPeer::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) { + Qt::ConnectionType type = QThread::currentThread() == receiver->thread() + ? Qt::DirectConnection + : Qt::QueuedConnection; + + if(type == Qt::DirectConnection) { + receiver->receivePeerSignal(sender, requestType, params); + } else { + QCoreApplication::postEvent(receiver, new PeerSignalEvent(sender, requestType, params)); + } +} + // ================================================== // SignalProxy // ================================================== @@ -217,12 +255,13 @@ SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent) setProxyMode(mode); addPeer(device); init(); -} +} SignalProxy::~SignalProxy() { QList senders = _relayHash.keys(); foreach(QObject* sender, senders) detachObject(sender); + removeAllPeers(); } void SignalProxy::setProxyMode(ProxyMode mode) { @@ -264,7 +303,7 @@ void SignalProxy::initClient() { bool SignalProxy::addPeer(QIODevice* iodev) { if(!iodev) return false; - + if(_peers.contains(iodev)) return true; @@ -273,21 +312,45 @@ bool SignalProxy::addPeer(QIODevice* iodev) { return false; } - if(!iodev->isOpen()) - qWarning("SignalProxy::the device you passed is not open!"); + if(!iodev->isOpen()) { + qWarning("SignalProxy::addPeer(QIODevice *iodev): iodev needs to be open!"); + return false; + } connect(iodev, SIGNAL(disconnected()), this, SLOT(removePeerBySender())); connect(iodev, SIGNAL(readyRead()), this, SLOT(dataAvailable())); - QAbstractSocket* sock = qobject_cast(iodev); - if(sock) { - connect(sock, SIGNAL(disconnected()), this, SLOT(removePeerBySender())); + if(!iodev->parent()) + iodev->setParent(this); + + _peers[iodev] = new IODevicePeer(iodev, iodev->property("UseCompression").toBool()); + + if(_peers.count() == 1) + emit connected(); + + return true; +} + +bool SignalProxy::addPeer(SignalProxy* proxy) { + if(!proxy) + return false; + + if(proxyMode() == proxy->proxyMode()) { + qWarning() << "SignalProxy::addPeer(): adding a SignalProxy as peer requires one proxy to be server and one client!"; + return false; } - // we take ownership of that device - iodev->setParent(this); + if(_peers.contains(proxy)) { + return true; + } - _peers[iodev] = new IODevicePeer(iodev, iodev->property("UseCompression").toBool()); + if(proxyMode() == Client && !_peers.isEmpty()) { + qWarning("SignalProxy: only one peer allowed in client mode!"); + return false; + } + + _peers[proxy] = new SignalProxyPeer(this, proxy); + proxy->addPeer(this); if(_peers.count() == 1) emit connected(); @@ -300,60 +363,46 @@ void SignalProxy::removeAllPeers() { // wee need to copy that list since we modify it in the loop QList peers = _peers.keys(); foreach(QObject *peer, peers) { - switch(_peers[peer]->type()) { - case AbstractPeer::IODevicePeer: - removePeer(static_cast(peer)); - break; - case AbstractPeer::SignalProxyPeer: - removePeer(static_cast(peer)); - break; - default: - Q_ASSERT(false); // there shouldn't be any peers with wrong / unknown type - } + removePeer(peer); } } -void SignalProxy::removePeer(QIODevice* iodev) { +void SignalProxy::removePeer(QObject* dev) { if(_peers.isEmpty()) { qWarning() << "SignalProxy::removePeer(): No peers in use!"; return; } - Q_ASSERT(iodev); - if(!_peers.contains(iodev)) { - qWarning() << "SignalProxy: unknown QIODevice" << iodev; + Q_ASSERT(dev); + if(!_peers.contains(dev)) { + qWarning() << "SignalProxy: unknown Peer" << dev; return; } - AbstractPeer *peer = _peers[iodev]; - _peers.remove(iodev); - delete peer; + AbstractPeer *peer = _peers[dev]; + _peers.remove(dev); - disconnect(iodev, 0, this, 0); - emit peerRemoved(iodev); + disconnect(dev, 0, this, 0); + if(peer->type() == AbstractPeer::IODevicePeer) + emit peerRemoved(static_cast(dev)); - if(_peers.isEmpty()) - emit disconnected(); -} - -void SignalProxy::removePeer(SignalProxy *proxy) { - if(!_peers.contains(proxy)) { - qWarning() << "SignalProxy: unknown QIODevice" << proxy; - return; + if(peer->type() == AbstractPeer::SignalProxyPeer) { + SignalProxy *proxy = static_cast(dev); + if(proxy->_peers.contains(this)) + proxy->removePeer(this); } - _peers.remove(proxy); + if(dev->parent() == this) + dev->deleteLater(); + + delete peer; if(_peers.isEmpty()) 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... - // this Slot is not triggered by destroyed, so the object is still alive and can be used! - QIODevice *ioDev = (QIODevice *)(sender()); - removePeer(ioDev); + removePeer(sender()); } void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) { @@ -364,7 +413,7 @@ void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) if(proxyMode() == Client) return; - + QVariantList params; params << "__objectRenamed__" << className << newname << oldname; dispatchSignal(RpcCall, params); @@ -448,7 +497,7 @@ const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) { void SignalProxy::setSyncMap(SyncableObject *obj) { const QMetaObject *meta = obj->syncMetaObject(); QHash syncMap; - + QList slotIndexes; for(int i = 0; i < meta->methodCount(); i++) { if(meta->method(i).methodType() == QMetaMethod::Slot) @@ -523,7 +572,7 @@ void SignalProxy::setReceiveMap(SyncableObject *obj) { signature = QByteArray(requestSlot.signature()); if(!signature.startsWith("request")) continue; - + paramsPos = signature.indexOf('('); if(paramsPos == -1) continue; @@ -545,7 +594,7 @@ void SignalProxy::setReceiveMap(SyncableObject *obj) { if(receiverId != -1) receiveMap[i] = receiverId; } - _classInfo[meta]->receiveMap = receiveMap; + _classInfo[meta]->receiveMap = receiveMap; } const QHash &SignalProxy::receiveMap(SyncableObject *obj) { @@ -627,7 +676,7 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha void SignalProxy::synchronize(SyncableObject *obj) { createClassInfo(obj); setUpdatedRemotelyId(obj); - + // attaching all the Signals SignalRelay* relay; if(_relayHash.contains(obj)) @@ -668,9 +717,9 @@ void SignalProxy::detachSender() { } void SignalProxy::detachObject(QObject* obj) { + stopSync(static_cast(obj)); detachSignals(obj); detachSlots(obj); - stopSync(static_cast(obj)); } void SignalProxy::detachSignals(QObject* sender) { @@ -713,7 +762,10 @@ void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantL case AbstractPeer::IODevicePeer: { IODevicePeer *ioPeer = static_cast(*peer); - ioPeer->dispatchPackedFunc(packedFunc); + if(ioPeer->isOpen()) + ioPeer->dispatchPackedFunc(packedFunc); + else + QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key())); } break; case AbstractPeer::SignalProxyPeer: @@ -737,7 +789,7 @@ void SignalProxy::receivePackedFunc(AbstractPeer *sender, const QVariant &packed RequestType requestType = (RequestType)params.takeFirst().value(); receivePeerSignal(sender, requestType, params); } - + void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList ¶ms) { switch(requestType) { case RpcCall: @@ -751,15 +803,15 @@ void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &req case Sync: handleSync(sender, params); break; - + case InitRequest: handleInitRequest(sender, params); break; - + case InitData: handleInitData(sender, params); break; - + case HeartBeat: receiveHeartBeat(sender, params); break; @@ -773,12 +825,21 @@ void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &req } } +void SignalProxy::receivePeerSignal(SignalProxy *sender, const RequestType &requestType, const QVariantList ¶ms) { + if(!_peers.contains(sender)) { + // we output only the pointer value. otherwise Qt would try to pretty print. As the object might already been destroyed, this is not a good idea. + qWarning() << "SignalProxy::receivePeerSignal(): received Signal from unknown Proxy" << reinterpret_cast(sender); + return; + } + receivePeerSignal(_peers[sender], requestType, params); +} + void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) { if(params.count() < 3) { qWarning() << "received invalid Sync call" << params; return; } - + QByteArray className = params.takeFirst().toByteArray(); QString objectName = params.takeFirst().toString(); QByteArray signal = params.takeFirst().toByteArray(); @@ -815,7 +876,7 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) { returnParams << returnValue; sender->dispatchSignal(Sync, returnParams); } - + // send emit update signal invokeSlot(receiver, updatedRemotelyId(receiver)); } @@ -826,10 +887,10 @@ void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &pa << params; return; } - + QByteArray className(params[0].toByteArray()); QString objectName(params[1].toString()); - + if(!_syncSlave.contains(className)) { qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" << className; @@ -841,7 +902,7 @@ void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &pa << className << objectName; return; } - + SyncableObject *obj = _syncSlave[className][objectName]; QVariantList params_; @@ -859,7 +920,7 @@ void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList ¶m << params; return; } - + QByteArray className(params[0].toByteArray()); QString objectName(params[1].toString()); QVariantMap propertyMap(params[2].toMap()); @@ -908,7 +969,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList return false; } - void *_a[] = {0, // return type... + 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}; @@ -928,7 +989,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList if(returnValue.type() != QVariant::Invalid) _a[0] = const_cast(returnValue.constData()); - + Qt::ConnectionType type = QThread::currentThread() == receiver->thread() ? Qt::DirectConnection : Qt::QueuedConnection; @@ -940,7 +1001,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList // note to self: qmetaobject.cpp:990 ff return false; } - + } bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms) { @@ -969,7 +1030,7 @@ void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool c QDataStream out(&block, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_4_2); out << (quint32)0; - + if(compressed) { QByteArray rawItem; QDataStream itemStream(&rawItem, QIODevice::WriteOnly); @@ -1000,30 +1061,35 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian } if(blockSize > 1 << 22) { - qWarning() << qPrintable(tr("Client tried to send package larger than max package size!")); - QAbstractSocket *sock = qobject_cast(dev); - qWarning() << qPrintable(tr("Disconnecting")) << (sock ? qPrintable(sock->peerAddress().toString()) : qPrintable(tr("local client"))); - dev->close(); + disconnectDevice(dev, tr("Client tried to send package larger than max package size!")); + return false; + } + + if(blockSize == 0) { + disconnectDevice(dev, tr("Client tried to send 0 byte package!")); return false; } - + if(dev->bytesAvailable() < blockSize) return false; + blockSize = 0; + if(compressed) { QByteArray rawItem; in >> rawItem; - // debug check + int nbytes = rawItem.size(); - if (nbytes <= 4) { + if(nbytes <= 4) { const char *data = rawItem.constData(); - if (nbytes < 4 || (data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0)) - qWarning() << "receieved corrupted compressed data:" - << blockSize << rawItem << rawItem.size() << dev; + if(nbytes < 4 || (data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0)) { + disconnectDevice(dev, tr("Client sent corrupted compressed data!")); + return false; + } } - // end + rawItem = qUncompress(rawItem); - + QDataStream itemStream(&rawItem, QIODevice::ReadOnly); itemStream.setVersion(QDataStream::Qt_4_2); itemStream >> item; @@ -1031,14 +1097,18 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian in >> item; } - blockSize = 0; + if(!item.isValid()) { + disconnectDevice(dev, tr("Client sent corrupt data: unable to load QVariant!")); + return false; + } return true; } bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const { // if we don't even have the same basename it's a sure NO - if(methodBaseName(signal) != methodBaseName(slot)) + QString baseName = methodBaseName(signal); + if(baseName != methodBaseName(slot)) return false; // are the signatures compatible? @@ -1046,11 +1116,20 @@ bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slo return false; // we take an educated guess if the signals and slots match - QString signalsuffix = ::methodName(signal).mid(QString(::methodName(signal)).lastIndexOf(QRegExp("[A-Z]"))).toLower(); - QString slotprefix = ::methodName(slot).left(QString(::methodName(slot)).indexOf(QRegExp("[A-Z]"))).toLower(); - + QString signalsuffix = ::methodName(signal); + QString slotprefix = ::methodName(slot); + if(!baseName.isEmpty()) { + signalsuffix = signalsuffix.mid(baseName.count()).toLower(); + slotprefix = slotprefix.left(slotprefix.count() - baseName.count()).toLower(); + } + uint sizediff = qAbs(slotprefix.size() - signalsuffix.size()); int ratio = editingDistance(slotprefix, signalsuffix) - sizediff; +// if(ratio < 2) { +// qDebug() << Q_FUNC_INFO; +// qDebug() << methodBaseName(signal) << methodBaseName(slot); +// qDebug() << signalsuffix << slotprefix << sizediff << ratio; +// } return (ratio < 2); } @@ -1092,21 +1171,20 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties } void SignalProxy::sendHeartBeat() { - dispatchSignal(SignalProxy::HeartBeat, QVariantList() << QTime::currentTime()); + QVariantList heartBeatParams; + heartBeatParams << QTime::currentTime(); PeerHash::iterator peer = _peers.begin(); while(peer != _peers.end()) { if((*peer)->type() == AbstractPeer::IODevicePeer) { IODevicePeer *ioPeer = static_cast(*peer); + ioPeer->dispatchSignal(SignalProxy::HeartBeat, heartBeatParams); if(ioPeer->sentHeartBeats > 0) { updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval()); } if(ioPeer->sentHeartBeats > 1) { - //FIXME: proper disconnect. -// QAbstractSocket *socket = qobject_cast(peerIter.key()); -// qWarning() << "SignalProxy: Disconnecting peer:" -// << (socket ? qPrintable(socket->peerAddress().toString()) : "local client") -// << "(didn't receive a heartbeat for over" << peerIter->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)"; -// peerIter.key()->close(); + qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address() + << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)"; + ioPeer->close(); } else { ioPeer->sentHeartBeats++; } @@ -1129,14 +1207,43 @@ void SignalProxy::receiveHeartBeatReply(AbstractPeer *peer, const QVariantList & ioPeer->sentHeartBeats = 0; if(params.isEmpty()) { - qWarning() << "SignalProxy: received heart beat reply with less params then sent from:" << ioPeer->device(); + qWarning() << "SignalProxy: received heart beat reply with less params then sent from:" << ioPeer->address(); return; } - + QTime sendTime = params[0].value(); updateLag(ioPeer, sendTime.msecsTo(QTime::currentTime()) / 2); } +void SignalProxy::customEvent(QEvent *event) { + switch(event->type()) { + case PeerSignal: + { + PeerSignalEvent *e = static_cast(event); + receivePeerSignal(e->sender, e->requestType, e->params); + } + event->accept(); + break; + case RemovePeer: + { + RemovePeerEvent *e = static_cast(event); + removePeer(e->peer); + } + event->accept(); + default: + return; + } +} + +void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason) { + if(!reason.isEmpty()) + qWarning() << qPrintable(reason); + QAbstractSocket *sock = qobject_cast(dev); + if(sock) + qWarning() << qPrintable(tr("Disconnecting")) << qPrintable(sock->peerAddress().toString()); + dev->close(); +} + void SignalProxy::updateLag(IODevicePeer *peer, int lag) { peer->lag = lag; if(proxyMode() == Client) { @@ -1159,7 +1266,7 @@ void SignalProxy::dumpProxyStats() { int slaveCount = 0; foreach(ObjectId oid, _syncSlave.values()) slaveCount += oid.count(); - + qDebug() << this; qDebug() << " Proxy Mode:" << mode; qDebug() << "attached sending Objects:" << _relayHash.count(); @@ -1176,13 +1283,7 @@ void SignalProxy::dumpSyncMap(SyncableObject *object) { QHash syncMap_ = syncMap(object); QHash::const_iterator iter = syncMap_.constBegin(); while(iter != syncMap_.constEnd()) { - qDebug() << iter.key() << "-->" << iter.value() << meta->method(iter.value()).signature(); + qDebug() << qPrintable(QString("%1 --> %2 %3").arg(QString(iter.key()), 40).arg(iter.value()).arg(QString(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++; -// } }