if(slotIter->sender == sender && (signalId == -1 || slotIter->signalId == signalId)) {
slotIter = _slots.erase(slotIter);
if(signalId != -1)
- break;
+ break;
} else {
slotIter++;
}
const QList<int> &argTypes = eMeta->argTypes(signal.signalId);
for(int i = 0; i < argTypes.size(); i++) {
- if(argTypes[i] == 0) {
- qWarning() << "SignalRelay::qt_metacall(): received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(caller->metaObject()->className()).arg(caller->metaObject()->method(_id).signature());
- qWarning() << " - make sure all your data types are known by the Qt MetaSystem";
- return _id;
- }
- params << QVariant(argTypes[i], _a[i+1]);
+ if(argTypes[i] == 0) {
+ qWarning() << "SignalRelay::qt_metacall(): received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(caller->metaObject()->className()).arg(caller->metaObject()->method(_id).signature());
+ qWarning() << " - make sure all your data types are known by the Qt MetaSystem";
+ return _id;
+ }
+ params << QVariant(argTypes[i], _a[i+1]);
}
proxy()->dispatchSignal(SignalProxy::RpcCall, params);
void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) {
QVariantList packedFunc;
packedFunc << (qint16)requestType
- << params;
+ << params;
dispatchPackedFunc(QVariant(packedFunc));
}
// SignalProxy
// ==================================================
SignalProxy::SignalProxy(QObject* parent)
- : QObject(parent)
+ : QObject(parent),
+ _heartBeatInterval(30),
+ _maxHeartBeatCount(2)
{
setProxyMode(Client);
init();
}
SignalProxy::~SignalProxy() {
- QList<SyncableObject *> syncObjects;
QHash<QByteArray, ObjectId>::iterator classIter = _syncSlave.begin();
while(classIter != _syncSlave.end()) {
- syncObjects << classIter->values();
+ ObjectId::iterator objIter = classIter->begin();
+ while(objIter != classIter->end()) {
+ SyncableObject *obj = objIter.value();
+ objIter = classIter->erase(objIter);
+ obj->stopSynchronize(this);
+ }
classIter++;
}
_syncSlave.clear();
- foreach(SyncableObject *obj, syncObjects) {
- obj->stopSynchronize(this);
- }
removeAllPeers();
}
if((*peer)->type() != AbstractPeer::IODevicePeer) {
IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
if(ioPeer->isOpen()) {
- qWarning() << "SignalProxy: Cannot change proxy mode while connected";
- return;
+ qWarning() << "SignalProxy: Cannot change proxy mode while connected";
+ return;
}
}
if((*peer)->type() != AbstractPeer::SignalProxyPeer) {
void SignalProxy::init() {
_signalRelay = new SignalRelay(this);
connect(&_heartBeatTimer, SIGNAL(timeout()), this, SLOT(sendHeartBeat()));
- _heartBeatTimer.start(30 * 1000);
+ setHeartBeatInterval(30);
+ setMaxHeartBeatCount(2);
+ _heartBeatTimer.start();
_secure = false;
updateSecureState();
}
return true;
}
+void SignalProxy::setHeartBeatInterval(int secs) {
+ if(secs != _heartBeatInterval) {
+ _heartBeatInterval = secs;
+ _heartBeatTimer.setInterval(secs * 1000);
+ }
+}
+
+void SignalProxy::setMaxHeartBeatCount(int max) {
+ _maxHeartBeatCount = max;
+}
+
bool SignalProxy::addPeer(SignalProxy* proxy) {
if(!proxy)
return false;
}
void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname) {
- qDebug() << "SignalProxy::objectRenamed" << classname << newname << oldname;
- if(proxyMode() == Server)
- return;
-
if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) {
SyncableObject *obj = _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
requestInit(obj);
switch((*peer)->type()) {
case AbstractPeer::IODevicePeer:
{
- IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
- if(ioPeer->isOpen())
- ioPeer->dispatchPackedFunc(packedFunc);
- else
- QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key()));
+ IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
+ if(ioPeer->isOpen())
+ ioPeer->dispatchPackedFunc(packedFunc);
+ else
+ QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key()));
}
break;
case AbstractPeer::SignalProxyPeer:
if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) {
qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName)
- << params;
+ << params;
return;
}
ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
if(!eMeta->slotMap().contains(slot)) {
qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName)
- << params;
+ << params;
return;
}
int receiverId = eMeta->receiveMap()[slotId];
QVariantList returnParams;
returnParams << className
- << objectName
- << eMeta->methodName(receiverId);
+ << objectName
+ << eMeta->methodName(receiverId);
//QByteArray(receiver->metaObject()->method(receiverId).signature());
if(eMeta->argTypes(receiverId).count() > 1)
returnParams << params;
void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList ¶ms) {
if(params.count() != 2) {
qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
- << params;
+ << params;
return;
}
if(!_syncSlave.contains(className)) {
qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
- << className;
+ << className;
return;
}
if(!_syncSlave[className].contains(objectName)) {
qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
- << className << objectName;
+ << className << objectName;
return;
}
QVariantList params_;
params_ << className
- << objectName
- << initData(obj);
+ << objectName
+ << initData(obj);
sender->dispatchSignal(InitData, params_);
}
Q_UNUSED(sender)
if(params.count() != 3) {
qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:"
- << params;
+ << params;
return;
}
if(!_syncSlave.contains(className)) {
qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:"
- << className;
+ << className;
return;
}
if(!_syncSlave[className].contains(objectName)) {
qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:"
- << className << objectName;
+ << className << objectName;
return;
}
}
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};
+ 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(nbytes <= 4) {
const char *data = rawItem.constData();
if(nbytes < 4 || (data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0)) {
- disconnectDevice(dev, tr("Peer sent corrupted compressed data!"));
- return false;
+ disconnectDevice(dev, tr("Peer sent corrupted compressed data!"));
+ return false;
}
}
QVariantList params;
params << obj->syncMetaObject()->className()
- << obj->objectName();
+ << obj->objectName();
dispatchSignal(InitRequest, params);
}
void SignalProxy::sendHeartBeat() {
QVariantList heartBeatParams;
heartBeatParams << QTime::currentTime();
+ QList<IODevicePeer *> toClose;
+
PeerHash::iterator peer = _peers.begin();
while(peer != _peers.end()) {
if((*peer)->type() == AbstractPeer::IODevicePeer) {
IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
ioPeer->dispatchSignal(SignalProxy::HeartBeat, heartBeatParams);
if(ioPeer->sentHeartBeats > 0) {
- updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval());
- }
- if(ioPeer->sentHeartBeats > 1) {
- qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address()
- << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)";
- ioPeer->close();
- } else {
- ioPeer->sentHeartBeats++;
+ updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval());
}
+ if(maxHeartBeatCount() >= 0 && ioPeer->sentHeartBeats >= maxHeartBeatCount())
+ toClose.append(ioPeer);
+ else
+ ioPeer->sentHeartBeats++;
}
- peer++;
+ ++peer;
+ }
+
+ foreach(IODevicePeer *ioPeer, toClose) {
+ qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address()
+ << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)";
+ ioPeer->close();
}
}
for(int i = 0; i < methodCount; i++) {
requestSlot = _meta->method(i);
if(requestSlot.methodType() != QMetaMethod::Slot)
- continue;
+ continue;
returnTypeName = requestSlot.typeName();
if(QMetaType::Void == (QMetaType::Type)returnType(i))
- continue;
+ continue;
signature = QByteArray(requestSlot.signature());
if(!signature.startsWith("request"))
- continue;
+ continue;
paramsPos = signature.indexOf('(');
if(paramsPos == -1)
- continue;
+ continue;
methodName = signature.left(paramsPos);
params = signature.mid(paramsPos);
receiverId = _meta->indexOfSlot(signature);
if(receiverId == -1) {
- signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")");
- receiverId = _meta->indexOfSlot(signature);
+ signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")");
+ receiverId = _meta->indexOfSlot(signature);
}
if(receiverId != -1) {
- receiveMap[i] = receiverId;
- qDebug() << requestSlot.signature() << _meta->method(receiverId).signature() << "---" << i << receiverId;
+ receiveMap[i] = receiverId;
}
}
_receiveMap = receiveMap;
projects / quassel.git / blobdiff