class CoreAccountModel;
class InternalPeer;
class Network;
+class Peer;
class SignalProxy;
class CoreConnection : public QObject
QVariantMap _coreMsgBuffer;
QPointer<QTcpSocket> _socket;
- QPointer<SignalProxy::AbstractPeer> _peer;
+ QPointer<Peer> _peer;
ConnectionState _state;
QTimer _reconnectTimer;
network.cpp
networkconfig.cpp
networkevent.cpp
+ peer.cpp
quassel.cpp
remotepeer.cpp
settings.cpp
ircuser.h
network.h
networkconfig.h
+ peer.h
remotepeer.h
settings.h
signalproxy.h
InternalPeer::InternalPeer(QObject *parent)
- : SignalProxy::AbstractPeer(parent),
+ : Peer(parent),
_proxy(0),
_peer(0),
_isOpen(true)
}
+::SignalProxy *InternalPeer::signalProxy() const
+{
+ return _proxy;
+}
+
+
void InternalPeer::setSignalProxy(::SignalProxy *proxy)
{
if (!proxy && _proxy) {
}
-template<class T>
-void InternalPeer::handle(const T &msg)
-{
- if (!_proxy) {
- qWarning() << Q_FUNC_INFO << "Cannot handle a message without having a signal proxy set!";
- return;
- }
-
- _proxy->handle(this, msg);
-}
-
-
void InternalPeer::customEvent(QEvent *event)
{
switch ((int)event->type()) {
#ifndef INTERNALPEER_H
#define INTERNALPEER_H
-#include <QTcpSocket>
-
+#include "peer.h"
#include "protocol.h"
#include "signalproxy.h"
class QEvent;
-class InternalPeer : public SignalProxy::AbstractPeer
+class InternalPeer : public Peer
{
Q_OBJECT
public slots:
void close(const QString &reason = QString());
-signals:
-
- void disconnected();
- void error(QAbstractSocket::SocketError);
-
protected:
void customEvent(QEvent *event);
template<class T>
void dispatch(EventType eventType, const T &msg);
- template<class T>
- void handle(const T &msg);
-
private:
SignalProxy *_proxy;
InternalPeer *_peer;
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005-2013 by the Quassel Project *
+ * devel@quassel-irc.org *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) version 3. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
+ ***************************************************************************/
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005-2013 by the Quassel Project *
+ * devel@quassel-irc.org *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) version 3. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
+ ***************************************************************************/
+
+#ifndef PEER_H
+#define PEER_H
+
+#include <QObject>
+
+#include "protocol.h"
+#include "signalproxy.h"
+
+class Peer : public QObject
+{
+ Q_OBJECT
+
+public:
+ Peer(QObject *parent = 0) : QObject(parent) {}
+
+ virtual QString description() const = 0;
+
+ virtual SignalProxy *signalProxy() const = 0;
+ virtual void setSignalProxy(SignalProxy *proxy) = 0;
+
+ virtual bool isOpen() const = 0;
+ virtual bool isSecure() const = 0;
+ virtual bool isLocal() const = 0;
+
+ virtual int lag() const = 0;
+
+public slots:
+ virtual void dispatch(const Protocol::SyncMessage &msg) = 0;
+ virtual void dispatch(const Protocol::RpcCall &msg) = 0;
+ virtual void dispatch(const Protocol::InitRequest &msg) = 0;
+ virtual void dispatch(const Protocol::InitData &msg) = 0;
+
+ virtual void close(const QString &reason = QString()) = 0;
+
+signals:
+ void disconnected();
+ void error(QAbstractSocket::SocketError);
+ void secureStateChanged(bool secure = true);
+ void lagUpdated(int msecs);
+
+protected:
+ template<class T>
+ void handle(const T &protoMessage);
+};
+
+
+// Template method needed in the header
+template<class T> inline
+void Peer::handle(const T &protoMessage)
+{
+ switch(protoMessage.handler()) {
+ case Protocol::SignalProxy:
+ if (!signalProxy()) {
+ qWarning() << Q_FUNC_INFO << "Cannot handle message without a SignalProxy!";
+ return;
+ }
+ signalProxy()->handle(this, protoMessage);
+ break;
+
+ default:
+ qWarning() << Q_FUNC_INFO << "Unknown handler for protocol message!";
+ return;
+ }
+}
+
+#endif
namespace Protocol {
+enum Handler {
+ SignalProxy
+};
+
+
/*** handled by SignalProxy ***/
class SyncMessage
inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList ¶ms)
: _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
+ inline Handler handler() const { return SignalProxy; }
+
inline QByteArray className() const { return _className; }
inline QString objectName() const { return _objectName; }
inline QByteArray slotName() const { return _slotName; }
inline RpcCall(const QByteArray &slotName, const QVariantList ¶ms)
: _slotName(slotName), _params(params) {}
+ inline Handler handler() const { return SignalProxy; }
+
inline QByteArray slotName() const { return _slotName; }
inline QVariantList params() const { return _params; }
inline InitRequest(const QByteArray &className, const QString &objectName)
: _className(className), _objectName(objectName) {}
+ inline Handler handler() const { return SignalProxy; }
+
inline QByteArray className() const { return _className; }
inline QString objectName() const { return _objectName; }
inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
: _className(className), _objectName(objectName), _initData(initData) {}
+ inline Handler handler() const { return SignalProxy; }
+
inline QByteArray className() const { return _className; }
inline QString objectName() const { return _objectName; }
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
+#include <QTcpSocket>
+
#include "legacypeer.h"
using namespace Protocol;
using namespace Protocol;
RemotePeer::RemotePeer(QTcpSocket *socket, QObject *parent)
- : SignalProxy::AbstractPeer(parent),
+ : Peer(parent),
_socket(socket),
_signalProxy(0),
_heartBeatTimer(new QTimer(this)),
#define REMOTEPEER_H
#include <QDateTime>
-#include <QTcpSocket>
+#include "peer.h"
#include "protocol.h"
#include "signalproxy.h"
+class QTcpSocket;
class QTimer;
-class RemotePeer : public SignalProxy::AbstractPeer
+class RemotePeer : public Peer
{
Q_OBJECT
// this is only used for the auth phase and should be replaced by something more generic
void dataReceived(const QVariant &item);
- void disconnected();
- void error(QAbstractSocket::SocketError);
-
void transferProgress(int current, int max);
protected:
int _lag;
};
-// Template methods we need in the header
+
template<class T> inline
void RemotePeer::handle(const T &protoMessage)
{
- if (!signalProxy()) {
- qWarning() << Q_FUNC_INFO << "Cannot handle messages without a SignalProxy!";
- return;
- }
-
- // _heartBeatCount = 0;
-
- signalProxy()->handle(this, protoMessage);
+ Peer::handle(protoMessage);
}
#include <QEvent>
#include <QCoreApplication>
+#include "peer.h"
#include "protocol.h"
#include "syncableobject.h"
#include "util.h"
class RemovePeerEvent : public QEvent
{
public:
- RemovePeerEvent(SignalProxy::AbstractPeer *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeerEvent)), peer(peer) {}
- SignalProxy::AbstractPeer *peer;
+ RemovePeerEvent(Peer *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeerEvent)), peer(peer) {}
+ Peer *peer;
};
}
-bool SignalProxy::addPeer(AbstractPeer *peer)
+bool SignalProxy::addPeer(Peer *peer)
{
if (!peer)
return false;
{
Q_ASSERT(proxyMode() == Server || _peers.count() <= 1);
// wee need to copy that list since we modify it in the loop
- QSet<AbstractPeer *> peers = _peers;
- foreach(AbstractPeer *peer, peers) {
+ QSet<Peer *> peers = _peers;
+ foreach(Peer *peer, peers) {
removePeer(peer);
}
}
-void SignalProxy::removePeer(AbstractPeer *peer)
+void SignalProxy::removePeer(Peer *peer)
{
if (!peer) {
qWarning() << Q_FUNC_INFO << "Trying to remove a null peer!";
void SignalProxy::removePeerBySender()
{
- removePeer(qobject_cast<SignalProxy::AbstractPeer *>(sender()));
+ removePeer(qobject_cast<Peer *>(sender()));
}
template<class T>
void SignalProxy::dispatch(const T &protoMessage)
{
- foreach (AbstractPeer *peer, _peers) {
+ foreach (Peer *peer, _peers) {
if (peer->isOpen())
peer->dispatch(protoMessage);
else
}
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SyncMessage &syncMessage)
+void SignalProxy::handle(Peer *peer, const SyncMessage &syncMessage)
{
if (!_syncSlave.contains(syncMessage.className()) || !_syncSlave[syncMessage.className()].contains(syncMessage.objectName())) {
qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className(), syncMessage.slotName(), syncMessage.objectName())
}
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const InitRequest &initRequest)
+void SignalProxy::handle(Peer *peer, const InitRequest &initRequest)
{
if (!_syncSlave.contains(initRequest.className())) {
qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
}
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const InitData &initData)
+void SignalProxy::handle(Peer *peer, const InitData &initData)
{
Q_UNUSED(peer)
}
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const RpcCall &rpcCall)
+void SignalProxy::handle(Peer *peer, const RpcCall &rpcCall)
{
Q_UNUSED(peer)
bool wasSecure = _secure;
_secure = !_peers.isEmpty();
- foreach (const AbstractPeer *peer, _peers) {
+ foreach (const Peer *peer, _peers) {
_secure &= peer->isSecure();
}
#include "protocol.h"
-class SyncableObject;
-struct QMetaObject;
+class QMetaObject;
+class Peer;
+class SyncableObject;
class SignalProxy : public QObject
{
class SignalRelay;
public:
- class AbstractPeer;
-
enum ProxyMode {
Server,
Client
void setMaxHeartBeatCount(int max);
inline int maxHeartBeatCount() const { return _maxHeartBeatCount; }
- bool addPeer(AbstractPeer *peer);
+ bool addPeer(Peer *peer);
bool attachSignal(QObject *sender, const char *signal, const QByteArray &sigName = QByteArray());
bool attachSlot(const QByteArray &sigName, QObject *recv, const char *slot);
void updateSecureState();
signals:
- void peerRemoved(SignalProxy::AbstractPeer *peer);
+ void peerRemoved(Peer *peer);
void connected();
void disconnected();
void objectInitialized(SyncableObject *);
static const QMetaObject *metaObject(const QObject *obj);
- void removePeer(AbstractPeer *peer);
+ void removePeer(Peer *peer);
void removeAllPeers();
template<class T>
void dispatch(const T &protoMessage);
- void handle(AbstractPeer *peer, const Protocol::SyncMessage &syncMessage);
- void handle(AbstractPeer *peer, const Protocol::RpcCall &rpcCall);
- void handle(AbstractPeer *peer, const Protocol::InitRequest &initRequest);
- void handle(AbstractPeer *peer, const Protocol::InitData &initData);
+ void handle(Peer *peer, const Protocol::SyncMessage &syncMessage);
+ void handle(Peer *peer, const Protocol::RpcCall &rpcCall);
+ void handle(Peer *peer, const Protocol::InitRequest &initRequest);
+ void handle(Peer *peer, const Protocol::InitData &initData);
+
+ template<class T>
+ void handle(Peer *peer, T) { Q_ASSERT(0); }
bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms, QVariant &returnValue);
bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms = QVariantList());
static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
- QSet<AbstractPeer *> _peers;
+ QSet<Peer *> _peers;
// containg a list of argtypes for fast access
QHash<const QMetaObject *, ExtendedMetaObject *> _extendedMetaObjects;
friend class SignalRelay;
friend class SyncableObject;
- friend class InternalPeer;
- friend class RemotePeer;
+ friend class Peer;
};
QHash<int, int> _receiveMap; // if slot x is called then hand over the result to slot y
};
-
-// ==================================================
-// AbstractPeer
-// ==================================================
-class SignalProxy::AbstractPeer : public QObject
-{
- Q_OBJECT
-
-public:
- AbstractPeer(QObject *parent = 0) : QObject(parent) {}
-
- virtual QString description() const = 0;
-
- virtual void setSignalProxy(SignalProxy *proxy) = 0;
-
- virtual bool isOpen() const = 0;
- virtual bool isSecure() const = 0;
- virtual bool isLocal() const = 0;
-
- virtual int lag() const = 0;
-
-public slots:
- virtual void dispatch(const Protocol::SyncMessage &msg) = 0;
- virtual void dispatch(const Protocol::RpcCall &msg) = 0;
- virtual void dispatch(const Protocol::InitRequest &msg) = 0;
- virtual void dispatch(const Protocol::InitData &msg) = 0;
-
- virtual void close(const QString &reason = QString()) = 0;
-
-signals:
- void disconnected();
- void error(QAbstractSocket::SocketError);
- void secureStateChanged(bool secure = true);
- void lagUpdated(int msecs);
-};
-
#endif
p->setHeartBeatInterval(30);
p->setMaxHeartBeatCount(60); // 30 mins until we throw a dead socket out
- connect(p, SIGNAL(peerRemoved(SignalProxy::AbstractPeer*)), SLOT(removeClient(SignalProxy::AbstractPeer*)));
+ connect(p, SIGNAL(peerRemoved(Peer*)), SLOT(removeClient(Peer*)));
connect(p, SIGNAL(connected()), SLOT(clientsConnected()));
connect(p, SIGNAL(disconnected()), SLOT(clientsDisconnected()));
}
-void CoreSession::removeClient(SignalProxy::AbstractPeer *peer)
+void CoreSession::removeClient(Peer *peer)
{
RemotePeer *p = qobject_cast<RemotePeer *>(peer);
if (p)
#include "corealiasmanager.h"
#include "coreignorelistmanager.h"
#include "message.h"
-#include "signalproxy.h"
#include "storage.h"
class CoreBacklogManager;
class EventStringifier;
class InternalPeer;
class IrcParser;
+class Peer;
class MessageEvent;
class NetworkConnection;
class RemotePeer;
+class SignalProxy;
struct NetworkInfo;
virtual void customEvent(QEvent *event);
private slots:
- void removeClient(SignalProxy::AbstractPeer *peer);
+ void removeClient(Peer *peer);
void recvStatusMsgFromServer(QString msg);
void recvMessageFromServer(NetworkId networkId, Message::Type, BufferInfo::Type, const QString &target, const QString &text, const QString &sender = "", Message::Flags flags = Message::None);