From 018d1d001bf3c051b55525f523d933a8d694e071 Mon Sep 17 00:00:00 2001 From: Marcus Eggenberger Date: Wed, 4 Jun 2008 19:22:18 +0200 Subject: [PATCH] Say hello to compression! This feature doesn't break protocol and is automagically enabled if both client and core support compression. Distclean is needed! --- src/client/clientsyncer.cpp | 12 ++++++ src/common/signalproxy.cpp | 80 ++++++++++++++++++++++++++----------- src/common/signalproxy.h | 12 ++++-- src/core/core.cpp | 18 ++++++++- 4 files changed, 94 insertions(+), 28 deletions(-) diff --git a/src/client/clientsyncer.cpp b/src/client/clientsyncer.cpp index b7b2088d..e7f68b01 100644 --- a/src/client/clientsyncer.cpp +++ b/src/client/clientsyncer.cpp @@ -160,6 +160,12 @@ void ClientSyncer::coreSocketConnected() { clientInit["ClientDate"] = Global::quasselDate; clientInit["ClientBuild"] = Global::quasselBuild; // this is a minimum, since we probably won't update for every commit clientInit["UseSsl"] = coreConnectionInfo["useSsl"]; +#ifndef QT_NO_COMPRESS + clientInit["UseCompression"] = true; +#else + clientInit["UseCompression"] = false; +#endif + SignalProxy::writeDataToDevice(socket, clientInit); } @@ -206,6 +212,12 @@ void ClientSyncer::clientInitAck(const QVariantMap &msg) { } #endif +#ifndef QT_NO_COMPRESS + if(msg["SupportsCompression"].toBool()) { + socket->setProperty("UseCompression", true); + } +#endif + if(!msg["Configured"].toBool()) { // start wizard emit startCoreSetup(msg["StorageBackends"].toList()); diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 22e71f13..f467b1b5 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -179,7 +179,7 @@ void SignalRelay::attachSignal(int methodId, const QByteArray &func) { sigNames.insert(methodId, fn); } // ==================== -// END SIGNALRELAY +// /SIGNALRELAY // ==================== @@ -211,14 +211,14 @@ SignalProxy::~SignalProxy() { detachObject(sender); // close peer connections - foreach(QIODevice *device, _peerByteCount.keys()) { + foreach(QIODevice *device, _peers.keys()) { device->close(); delete device; } } void SignalProxy::setProxyMode(ProxyMode mode) { - foreach(QIODevice* peer, _peerByteCount.keys()) { + foreach(QIODevice* peer, _peers.keys()) { if(peer->isOpen()) { qWarning() << "SignalProxy: Cannot change proxy mode while connected"; return; @@ -251,10 +251,10 @@ bool SignalProxy::addPeer(QIODevice* iodev) { if(!iodev) return false; - if(_peerByteCount.contains(iodev)) + if(_peers.contains(iodev)) return true; - if(proxyMode() == Client && !_peerByteCount.isEmpty()) { + if(proxyMode() == Client && !_peers.isEmpty()) { qWarning("SignalProxy: only one peer allowed in client mode!"); return false; } @@ -270,43 +270,45 @@ bool SignalProxy::addPeer(QIODevice* iodev) { connect(sock, SIGNAL(disconnected()), this, SLOT(removePeerBySender())); } - _peerByteCount[iodev] = 0; + _peers[iodev] = peerInfo(); + if(iodev->property("UseCompression").toBool()) + _peers[iodev].usesCompression = true; - if(_peerByteCount.count() == 1) + if(_peers.count() == 1) emit connected(); return true; } void SignalProxy::removePeer(QIODevice* iodev) { - if(_peerByteCount.isEmpty()) { + if(_peers.isEmpty()) { qWarning() << "SignalProxy::removePeer(): No peers in use!"; return; } if(proxyMode() == Server && !iodev) { // disconnect all - QList peers = _peerByteCount.keys(); + QList peers = _peers.keys(); foreach(QIODevice *peer, peers) removePeer(peer); } if(proxyMode() != Server && !iodev) - iodev = _peerByteCount.keys().first(); + iodev = _peers.keys().first(); Q_ASSERT(iodev); - if(!_peerByteCount.contains(iodev)) { + if(!_peers.contains(iodev)) { qWarning() << "SignalProxy: unknown QIODevice" << iodev; return; } - _peerByteCount.remove(iodev); + _peers.remove(iodev); disconnect(iodev, 0, this, 0); emit peerRemoved(iodev); - if(_peerByteCount.isEmpty()) + if(_peers.isEmpty()) emit disconnected(); } @@ -672,10 +674,11 @@ void SignalProxy::stopSync(SyncableObject* obj) { } void SignalProxy::dispatchSignal(QIODevice *receiver, const RequestType &requestType, const QVariantList ¶ms) { + Q_ASSERT(_peers.contains(receiver)); QVariantList packedFunc; packedFunc << (qint16)requestType; packedFunc << params; - writeDataToDevice(receiver, QVariant(packedFunc)); + writeDataToDevice(receiver, QVariant(packedFunc), _peers[receiver].usesCompression); } void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) { @@ -683,8 +686,10 @@ void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantL QVariantList packedFunc; packedFunc << (qint16)requestType; packedFunc << params; - foreach(QIODevice* dev, _peerByteCount.keys()) - writeDataToDevice(dev, QVariant(packedFunc)); + foreach(QIODevice* dev, _peers.keys()) { + Q_ASSERT(_peers.contains(dev)); + writeDataToDevice(dev, QVariant(packedFunc), _peers[dev].usesCompression); + } } void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFunc) { @@ -893,27 +898,43 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList void SignalProxy::dataAvailable() { // yet again. it's a private slot. no need for checks. QIODevice* ioDev = qobject_cast(sender()); + Q_ASSERT(_peers.contains(ioDev)); QVariant var; - while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var)) + while(readDataFromDevice(ioDev, _peers[ioDev].byteCount, var, _peers[ioDev].usesCompression)) receivePeerSignal(ioDev, var); } -void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item) { +void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool compressed) { QAbstractSocket* sock = qobject_cast(dev); if(!dev->isOpen() || (sock && sock->state()!=QAbstractSocket::ConnectedState)) { qWarning("SignalProxy: Can't call on a closed device"); return; } + QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_4_2); - out << (quint32)0 << item; - out.device()->seek(0); - out << (quint32)(block.size() - sizeof(quint32)); + + if(compressed) { + QByteArray rawItem; + QDataStream itemStream(&rawItem, QIODevice::WriteOnly); + + itemStream.setVersion(QDataStream::Qt_4_2); + itemStream << item; + + rawItem = qCompress(rawItem); + + out << (quint32)rawItem.size() << rawItem; + } else { + out << (quint32)0 << item; + out.device()->seek(0); + out << (quint32)(block.size() - sizeof(quint32)); + } + dev->write(block); } -bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item) { +bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed) { QDataStream in(dev); in.setVersion(QDataStream::Qt_4_2); @@ -924,8 +945,21 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian if(dev->bytesAvailable() < blockSize) return false; - in >> item; + + if(compressed) { + QByteArray rawItem; + in >> rawItem; + rawItem = qUncompress(rawItem); + + QDataStream itemStream(&rawItem, QIODevice::ReadOnly); + itemStream.setVersion(QDataStream::Qt_4_2); + itemStream >> item; + } else { + in >> item; + } + blockSize = 0; + return true; } diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h index 1090547e..7ffb73bb 100644 --- a/src/common/signalproxy.h +++ b/src/common/signalproxy.h @@ -81,13 +81,13 @@ public: * so the corresponding function readDataFromDevice() can check if enough data is available * at the device to reread the item. */ - static void writeDataToDevice(QIODevice *dev, const QVariant &item); + static void writeDataToDevice(QIODevice *dev, const QVariant &item, bool compressed = false); //! Reads a data item from a device that has been written by writeDataToDevice(). /** If not enough data bytes are available, the function returns false and the QVariant reference * remains untouched. */ - static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item); + static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed = false); static QString methodBaseName(const QMetaMethod &method); @@ -163,7 +163,13 @@ public: private: // Hash of used QIODevices - QHash _peerByteCount; + struct peerInfo { + quint32 byteCount; + bool usesCompression; + peerInfo() : byteCount(0), usesCompression(false) {}; + }; + //QHash _peerByteCount; + QHash _peers; // containg a list of argtypes for fast access QHash _classInfo; diff --git a/src/core/core.cpp b/src/core/core.cpp index 1af89261..f413bbf2 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -401,9 +401,16 @@ void Core::processClientMessage(QTcpSocket *socket, const QVariantMap &msg) { #else bool supportSsl = false; #endif + +#ifndef QT_NO_COMPRESS + bool supportsCompression = true; +#else + bool supportsCompression = false; +#endif reply["SupportSsl"] = supportSsl; - // switch to ssl after client has been informed about our capabilities (see below) + reply["SupportsCompression"] = supportsCompression; + // switch to ssl/compression after client has been informed about our capabilities (see below) reply["LoginEnabled"] = true; @@ -439,12 +446,19 @@ void Core::processClientMessage(QTcpSocket *socket, const QVariantMap &msg) { #ifndef QT_NO_OPENSSL // after we told the client that we are ssl capable we switch to ssl mode if(supportSsl && msg["UseSsl"].toBool()) { - qDebug() << "Starting TLS for Client:" << qPrintable(socket->peerAddress().toString()); + qDebug() << "Starting TLS for Client:" << qPrintable(socket->peerAddress().toString()); connect(sslSocket, SIGNAL(sslErrors(const QList &)), this, SLOT(sslErrors(const QList &))); sslSocket->startServerEncryption(); } #endif +#ifndef QT_NO_COMPRESS + if(supportsCompression && msg["UseCompression"].toBool()) { + socket->setProperty("UseCompression", true); + qDebug() << "Using compression for Client:" << qPrintable(socket->peerAddress().toString()); + } +#endif + } else { // for the rest, we need an initialized connection if(!clientInfo.contains(socket)) { -- 2.20.1