X-Git-Url: https://git.quassel-irc.org/?a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.h;h=645157ef84b6a8778f8bf1161bbd32e17b229d3a;hb=0e1b154;hp=a76a352017ceafbf46ae510e38df4b2748b94260;hpb=57e1cccf5a990b83bc8bde7959e85dec99db50a7;p=quassel.git

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index a76a3520..645157ef 100644
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-09 by the Quassel Project                          *
+ *   Copyright (C) 2005-2012 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -15,18 +15,20 @@
  *   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.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 #ifndef SIGNALPROXY_H
 #define SIGNALPROXY_H
 
+#include <QAbstractSocket>
 #include <QEvent>
 #include <QList>
 #include <QHash>
 #include <QVariant>
 #include <QVariantMap>
 #include <QPair>
+#include <QSet>
 #include <QString>
 #include <QByteArray>
 #include <QTimer>
@@ -34,277 +36,310 @@
 class SyncableObject;
 struct QMetaObject;
 
-class SignalProxy : public QObject {
-  Q_OBJECT
+class SignalProxy : public QObject
+{
+    Q_OBJECT
 
-  class AbstractPeer;
-  class IODevicePeer;
-  class SignalProxyPeer;
-
-  class SignalRelay;
+    class SignalRelay;
 
 public:
-  enum ProxyMode {
-    Server,
-    Client
-  };
-
-  enum RequestType {
-    Sync = 1,
-    RpcCall,
-    InitRequest,
-    InitData,
-    HeartBeat,
-    HeartBeatReply
-  };
-
-  enum ClientConnectionType {
-    SignalProxyConnection,
-    IODeviceConnection
-  };
-
-  enum CustomEvents {
-    PeerSignal = QEvent::User,
-    RemovePeer
-  };
-
-  SignalProxy(QObject *parent);
-  SignalProxy(ProxyMode mode, QObject *parent);
-  SignalProxy(ProxyMode mode, QIODevice *device, QObject *parent);
-  virtual ~SignalProxy();
-
-  void setProxyMode(ProxyMode mode);
-  inline ProxyMode proxyMode() const { return _proxyMode; }
-
-  bool addPeer(QIODevice *iodev);
-  bool addPeer(SignalProxy *proxy);
-  void removePeer(QObject *peer);
-  void removeAllPeers();
-
-  bool attachSignal(QObject *sender, const char *signal, const QByteArray& sigName = QByteArray());
-  bool attachSlot(const QByteArray& sigName, QObject *recv, const char *slot);
-
-  void synchronize(SyncableObject *obj);
-
-  //! Writes a QVariant to a device.
-  /** The data item is prefixed with the resulting blocksize,
-   *  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, 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, bool compressed = false);
-
-  class ExtendedMetaObject;
-  ExtendedMetaObject *extendedMetaObject(const QMetaObject *meta) const;
-  ExtendedMetaObject *createExtendedMetaObject(const QMetaObject *meta);
-  inline ExtendedMetaObject *extendedMetaObject(const QObject *obj) const { return extendedMetaObject(metaObject(obj)); }
-  inline ExtendedMetaObject *createExtendedMetaObject(const QObject *obj) { return createExtendedMetaObject(metaObject(obj)); }
-
-  bool isSecure() const { return _secure; }
-  void dumpProxyStats();
+    class AbstractPeer;
+
+    class SyncMessage;
+    class RpcCall;
+    class InitRequest;
+    class InitData;
+
+    enum ProxyMode {
+        Server,
+        Client
+    };
+
+    enum EventType {
+        RemovePeerEvent = QEvent::User
+    };
+
+    SignalProxy(QObject *parent);
+    SignalProxy(ProxyMode mode, QObject *parent);
+    virtual ~SignalProxy();
+
+    void setProxyMode(ProxyMode mode);
+    inline ProxyMode proxyMode() const { return _proxyMode; }
+
+    void setHeartBeatInterval(int secs);
+    inline int heartBeatInterval() const { return _heartBeatInterval; }
+    void setMaxHeartBeatCount(int max);
+    inline int maxHeartBeatCount() const { return _maxHeartBeatCount; }
+
+    bool addPeer(AbstractPeer *peer);
+
+    bool attachSignal(QObject *sender, const char *signal, const QByteArray &sigName = QByteArray());
+    bool attachSlot(const QByteArray &sigName, QObject *recv, const char *slot);
+
+    void synchronize(SyncableObject *obj);
+    void stopSynchronize(SyncableObject *obj);
+
+    class ExtendedMetaObject;
+    ExtendedMetaObject *extendedMetaObject(const QMetaObject *meta) const;
+    ExtendedMetaObject *createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts = false);
+    inline ExtendedMetaObject *extendedMetaObject(const QObject *obj) const { return extendedMetaObject(metaObject(obj)); }
+    inline ExtendedMetaObject *createExtendedMetaObject(const QObject *obj, bool checkConflicts = false) { return createExtendedMetaObject(metaObject(obj), checkConflicts); }
+
+    bool isSecure() const { return _secure; }
+    void dumpProxyStats();
+    void dumpSyncMap(SyncableObject *object);
+    inline int peerCount() const { return _peers.size(); }
 
 public slots:
-  void detachObject(QObject *obj);
-  void detachSignals(QObject *sender);
-  void detachSlots(QObject *receiver);
-  void stopSync(QObject *obj);
+    void detachObject(QObject *obj);
+    void detachSignals(QObject *sender);
+    void detachSlots(QObject *receiver);
 
 protected:
-  void customEvent(QEvent *event);
-  void syncCall(const SyncableObject *obj, ProxyMode modeType, const char *funcname, va_list ap);
+    void customEvent(QEvent *event);
+    void sync_call__(const SyncableObject *obj, ProxyMode modeType, const char *funcname, va_list ap);
+    void renameObject(const SyncableObject *obj, const QString &newname, const QString &oldname);
 
 private slots:
-  void dataAvailable();
-  void removePeerBySender();
-  void objectRenamed(const QString &newname, const QString &oldname);
-  void objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname);
-  void sendHeartBeat();
-  void receiveHeartBeat(AbstractPeer *peer, const QVariantList &params);
-  void receiveHeartBeatReply(AbstractPeer *peer, const QVariantList &params);
-
-  void updateSecureState();
+    void removePeerBySender();
+    void objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname);
+    void updateSecureState();
 
 signals:
-  void peerRemoved(QIODevice *dev);
-  void connected();
-  void disconnected();
-  void objectInitialized(SyncableObject *);
-  void lagUpdated(int lag);
-  void securityChanged(bool);
-  void secureStateChanged(bool);
+    void peerRemoved(SignalProxy::AbstractPeer *peer);
+    void connected();
+    void disconnected();
+    void objectInitialized(SyncableObject *);
+    void heartBeatIntervalChanged(int secs);
+    void maxHeartBeatCountChanged(int max);
+    void lagUpdated(int lag);
+    void secureStateChanged(bool);
 
 private:
-  void init();
-  void initServer();
-  void initClient();
+    template<class T>
+    class PeerMessageEvent;
+
+    void init();
+    void initServer();
+    void initClient();
 
-  static const QMetaObject *metaObject(const QObject *obj);
+    static const QMetaObject *metaObject(const QObject *obj);
 
-  void dispatchSignal(QIODevice *receiver, const RequestType &requestType, const QVariantList &params);
-  void dispatchSignal(const RequestType &requestType, const QVariantList &params);
+    void removePeer(AbstractPeer *peer);
+    void removeAllPeers();
 
-  void receivePackedFunc(AbstractPeer *sender, const QVariant &packedFunc);
-  void receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList &params);
-  void receivePeerSignal(SignalProxy *sender, const RequestType &requestType, const QVariantList &params);
-  void handleSync(AbstractPeer *sender, QVariantList params);
-  void handleInitRequest(AbstractPeer *sender, const QVariantList &params);
-  void handleInitData(AbstractPeer *sender, const QVariantList &params);
-  void handleSignal(const QVariantList &data);
+    template<class T>
+    void dispatch(const T &protoMessage);
 
-  bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
-  bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
+    void handle(AbstractPeer *peer, const SyncMessage &syncMessage);
+    void handle(AbstractPeer *peer, const RpcCall &rpcCall);
+    void handle(AbstractPeer *peer, const InitRequest &initRequest);
+    void handle(AbstractPeer *peer, const InitData &initData);
 
-  void requestInit(SyncableObject *obj);
-  QVariantMap initData(SyncableObject *obj) const;
-  void setInitData(SyncableObject *obj, const QVariantMap &properties);
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
 
-  void updateLag(IODevicePeer *peer, int lag);
+    void requestInit(SyncableObject *obj);
+    QVariantMap initData(SyncableObject *obj) const;
+    void setInitData(SyncableObject *obj, const QVariantMap &properties);
 
+    static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
+
+    QSet<AbstractPeer *> _peers;
+
+    // containg a list of argtypes for fast access
+    QHash<const QMetaObject *, ExtendedMetaObject *> _extendedMetaObjects;
+
+    // SignalRelay for all manually attached signals
+    SignalRelay *_signalRelay;
+
+    // RPC function -> (object, slot ID)
+    typedef QPair<QObject *, int> MethodId;
+    typedef QMultiHash<QByteArray, MethodId> SlotHash;
+    SlotHash _attachedSlots;
+
+    // slaves for sync
+    typedef QHash<QString, SyncableObject *> ObjectId;
+    QHash<QByteArray, ObjectId> _syncSlave;
+
+    ProxyMode _proxyMode;
+    int _heartBeatInterval;
+    int _maxHeartBeatCount;
+
+    bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
+
+    friend class SignalRelay;
+    friend class SyncableObject;
+    friend class InternalConnection;
+    friend class RemoteConnection;
+};
+
+
+// ==================================================
+//  ExtendedMetaObject
+// ==================================================
+class SignalProxy::ExtendedMetaObject
+{
+    class MethodDescriptor
+    {
 public:
-  void dumpSyncMap(SyncableObject *object);
-  inline int peerCount() const { return _peers.size(); }
+        MethodDescriptor(const QMetaMethod &method);
+        MethodDescriptor() : _returnType(-1), _minArgCount(-1), _receiverMode(SignalProxy::Client) {}
+
+        inline const QByteArray &methodName() const { return _methodName; }
+        inline const QList<int> &argTypes() const { return _argTypes; }
+        inline int returnType() const { return _returnType; }
+        inline int minArgCount() const { return _minArgCount; }
+        inline SignalProxy::ProxyMode receiverMode() const { return _receiverMode; }
 
 private:
-  static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
+        QByteArray _methodName;
+        QList<int> _argTypes;
+        int _returnType;
+        int _minArgCount;
+        SignalProxy::ProxyMode _receiverMode; // Only acceptable as a Sync Call if the receiving SignalProxy is in this mode.
+    };
 
-  // a Hash of the actual used communication object to it's corresponding peer
-  // currently a communication object can either be an arbitrary QIODevice or another SignalProxy
-  typedef QHash<QObject *, AbstractPeer *> PeerHash;
-  PeerHash _peers;
 
-  // containg a list of argtypes for fast access
-  QHash<const QMetaObject *, ExtendedMetaObject *> _extendedMetaObjects;
+public:
+    ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts);
 
-  // SignalRelay for all manually attached signals
-  SignalRelay *_signalRelay;
+    inline const QByteArray &methodName(int methodId) { return methodDescriptor(methodId).methodName(); }
+    inline const QList<int> &argTypes(int methodId) { return methodDescriptor(methodId).argTypes(); }
+    inline int returnType(int methodId) { return methodDescriptor(methodId).returnType(); }
+    inline int minArgCount(int methodId) { return methodDescriptor(methodId).minArgCount(); }
+    inline SignalProxy::ProxyMode receiverMode(int methodId) { return methodDescriptor(methodId).receiverMode(); }
 
-  // RPC function -> (object, slot ID)
-  typedef QPair<QObject*, int> MethodId;
-  typedef QMultiHash<QByteArray, MethodId> SlotHash;
-  SlotHash _attachedSlots;
+    inline int methodId(const QByteArray &methodName) { return _methodIds.contains(methodName) ? _methodIds[methodName] : -1; }
 
-  // slaves for sync
-  typedef QHash<QString, SyncableObject *> ObjectId;
-  QHash<QByteArray, ObjectId> _syncSlave;
+    inline int updatedRemotelyId() { return _updatedRemotelyId; }
 
+    inline const QHash<QByteArray, int> &slotMap() { return _methodIds; }
+    const QHash<int, int> &receiveMap();
 
-  ProxyMode _proxyMode;
-  QTimer _heartBeatTimer;
+    const QMetaObject *metaObject() const { return _meta; }
 
-  bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
+    static QByteArray methodName(const QMetaMethod &method);
+    static QString methodBaseName(const QMetaMethod &method);
 
-  friend class SignalRelay;
-  friend class SyncableObject;
+private:
+    const MethodDescriptor &methodDescriptor(int methodId);
+
+    const QMetaObject *_meta;
+    int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
+
+    QHash<int, MethodDescriptor> _methods;
+    QHash<QByteArray, int> _methodIds;
+    QHash<int, int> _receiveMap; // if slot x is called then hand over the result to slot y
 };
 
 
 // ==================================================
-//  ExtendedMetaObject
+//  AbstractPeer
 // ==================================================
-class SignalProxy::ExtendedMetaObject {
-  class MethodDescriptor {
-  public:
-    MethodDescriptor(const QMetaMethod &method);
-    MethodDescriptor() : _returnType(-1), _minArgCount(-1) {}
-
-    inline const QByteArray &methodName() const { return _methodName; }
-    inline const QList<int> &argTypes() const { return _argTypes; }
-    inline int returnType() const { return _returnType; }
-    inline int minArgCount() const { return _minArgCount; }
-
-  private:
-    QByteArray _methodName;
-    QList<int> _argTypes;
-    int _returnType;
-    int _minArgCount;
-  };
+class SignalProxy::AbstractPeer : public QObject
+{
+    Q_OBJECT
 
 public:
-  ExtendedMetaObject(const QMetaObject *meta);
+    AbstractPeer(QObject *parent = 0) : QObject(parent) {}
 
-  inline const QByteArray &methodName(int methodId) { return methodDescriptor(methodId).methodName(); }
-  inline const QList<int> &argTypes(int methodId) { return methodDescriptor(methodId).argTypes(); }
-  inline int returnType(int methodId) { return methodDescriptor(methodId).returnType(); }
-  inline int minArgCount(int methodId) { return methodDescriptor(methodId).minArgCount(); }
+    virtual QString description() const = 0;
 
-  inline int updatedRemotelyId() { return _updatedRemotelyId; }
-  
-  int methodId(const QByteArray &methodName);
-  const QHash<QByteArray, int> &syncMap();
-  const QHash<int, int> &receiveMap();
+    virtual void setSignalProxy(SignalProxy *proxy) = 0;
 
-  const QMetaObject *metaObject() const { return _meta; }
+    virtual bool isOpen() const = 0;
+    virtual bool isSecure() const = 0;
+    virtual bool isLocal() const = 0;
 
-  static QByteArray methodName(const QMetaMethod &method);
-  static bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot);
-  static QString methodBaseName(const QMetaMethod &method);
+    virtual QString errorString() const { return QString(); }
 
-private:
-  const MethodDescriptor &methodDescriptor(int methodId);
+    virtual int lag() const = 0;
 
-  const QMetaObject *_meta;
-  QHash<int, MethodDescriptor> _methods;
-  QHash<QByteArray, int> _methodIds;
+public slots:
+    virtual void dispatch(const SyncMessage &msg) = 0;
+    virtual void dispatch(const RpcCall &msg) = 0;
+    virtual void dispatch(const InitRequest &msg) = 0;
+    virtual void dispatch(const InitData &msg) = 0;
 
-  int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
+    virtual void close(const QString &reason = QString()) = 0;
 
-  QHash<QByteArray, int> _syncMap;
-  QHash<int, int> _receiveMap;
+signals:
+    void disconnected();
+    void error(QAbstractSocket::SocketError);
+    void secureStateChanged(bool secure = true);
+    void lagUpdated(int msecs);
 };
 
 
 // ==================================================
-//  Peers
+//  Protocol Messages
 // ==================================================
-class SignalProxy::AbstractPeer {
+class SignalProxy::SyncMessage
+{
 public:
-  enum PeerType {
-    NotAPeer = 0,
-    IODevicePeer = 1,
-    SignalProxyPeer = 2
-  };
-  AbstractPeer() : _type(NotAPeer) {}
-  AbstractPeer(PeerType type) : _type(type) {}
-  virtual ~AbstractPeer() {}
-  inline PeerType type() const { return _type; }
-  virtual void dispatchSignal(const RequestType &requestType, const QVariantList &params) = 0;
-  virtual bool isSecure() const = 0;
+    inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList &params)
+    : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
+
+    inline QByteArray className() const { return _className; }
+    inline QString objectName() const { return _objectName; }
+    inline QByteArray slotName() const { return _slotName; }
+
+    inline QVariantList params() const { return _params; }
+
 private:
-  PeerType _type;
+    QByteArray _className;
+    QString _objectName;
+    QByteArray _slotName;
+    QVariantList _params;
 };
 
-class SignalProxy::IODevicePeer : public SignalProxy::AbstractPeer {
+
+class SignalProxy::RpcCall
+{
 public:
-  IODevicePeer(QIODevice *device, bool compress) : AbstractPeer(AbstractPeer::IODevicePeer), _device(device), byteCount(0), usesCompression(compress), sentHeartBeats(0), lag(0) {}
-  virtual void dispatchSignal(const RequestType &requestType, const QVariantList &params);
-  virtual bool isSecure() const;
-  inline void dispatchPackedFunc(const QVariant &packedFunc) { SignalProxy::writeDataToDevice(_device, packedFunc, usesCompression); }
-  QString address() const;
-  inline bool isOpen() const { return _device->isOpen(); }
-  inline void close() const { _device->close(); }
-  inline bool readData(QVariant &item) { return SignalProxy::readDataFromDevice(_device, byteCount, item, usesCompression); }
+    inline RpcCall(const QByteArray &slotName, const QVariantList &params)
+    : _slotName(slotName), _params(params) {}
+
+    inline QByteArray slotName() const { return _slotName; }
+    inline QVariantList params() const { return _params; }
+
 private:
-  QIODevice *_device;
-  quint32 byteCount;
-  bool usesCompression;
+    QByteArray _slotName;
+    QVariantList _params;
+};
+
+
+class SignalProxy::InitRequest
+{
 public:
-  int sentHeartBeats;
-  int lag;
+    inline InitRequest(const QByteArray &className, const QString &objectName)
+    : _className(className), _objectName(objectName) {}
+
+    inline QByteArray className() const { return _className; }
+    inline QString objectName() const { return _objectName; }
+
+private:
+    QByteArray _className;
+    QString _objectName;
 };
 
-class SignalProxy::SignalProxyPeer : public SignalProxy::AbstractPeer {
+
+class SignalProxy::InitData
+{
 public:
-  SignalProxyPeer(SignalProxy *sender, SignalProxy *receiver) : AbstractPeer(AbstractPeer::SignalProxyPeer), sender(sender), receiver(receiver) {}
-  virtual void dispatchSignal(const RequestType &requestType, const QVariantList &params);
-  virtual inline bool isSecure() const { return true; }
+    inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
+    : _className(className), _objectName(objectName), _initData(initData) {}
+
+    inline QByteArray className() const { return _className; }
+    inline QString objectName() const { return _objectName; }
+
+    inline QVariantMap initData() const { return _initData; }
+
 private:
-  SignalProxy *sender;
-  SignalProxy *receiver;
+    QByteArray _className;
+    QString _objectName;
+    QVariantMap _initData;
 };
 
 #endif