X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.h;h=a966700520581c743ec2a9d81c9e1f149b4073a9;hp=584626e0ff4089e1eb136373ea77ee1a957faf60;hb=c2fc6343afb7ac0bba9fc5a019fdadbefc35f546;hpb=d5095471627f6399b277d7c6d06b6bbcb915c57f

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index 584626e0..a9667005 100644
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-08 by the Quassel Project                          *
+ *   Copyright (C) 2005-2013 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -15,272 +15,256 @@
  *   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>
 
-class SignalRelay;
+#include "protocol.h"
+
 class SyncableObject;
 struct QMetaObject;
 
-class SignalProxy : public QObject {
-  Q_OBJECT
 
-  class AbstractPeer;
-  class IODevicePeer;
-  class SignalProxyPeer;
+class SignalProxy : public QObject
+{
+    Q_OBJECT
+
+    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);
-
-//   void setInitialized(SyncableObject *obj);
-//   bool isInitialized(SyncableObject *obj) const;
-  void detachObject(QObject *obj);
-  void detachSignals(QObject *sender);
-  void detachSlots(QObject *receiver);
-  void stopSync(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 QObject *obj) const;
-  void createExtendedMetaObject(const QObject *obj);
-
-  bool isSecure() const { return _secure; }
-  void dumpProxyStats();
+    class AbstractPeer;
+
+    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);
 
 protected:
-  void customEvent(QEvent *event);
+    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 detachSender();
-  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();
-
-  static const QMetaObject *metaObject(const QObject *obj);
+    template<class T>
+    class PeerMessageEvent;
 
-  void dispatchSignal(QIODevice *receiver, const RequestType &requestType, const QVariantList &params);
-  void dispatchSignal(const RequestType &requestType, const QVariantList &params);
+    void init();
+    void initServer();
+    void initClient();
 
-  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);
+    static const QMetaObject *metaObject(const QObject *obj);
 
-  bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
-  bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
+    void removePeer(AbstractPeer *peer);
+    void removeAllPeers();
 
-  void requestInit(SyncableObject *obj);
-  QVariantMap initData(SyncableObject *obj) const;
-  void setInitData(SyncableObject *obj, const QVariantMap &properties);
+    template<class T>
+    void dispatch(const T &protoMessage);
 
-  void updateLag(IODevicePeer *peer, int lag);
+    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);
 
-public:
-  void dumpSyncMap(SyncableObject *object);
-  inline int peerCount() const { return _peers.size(); }
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
 
-private:
-  static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
+    void requestInit(SyncableObject *obj);
+    QVariantMap initData(SyncableObject *obj) const;
+    void setInitData(SyncableObject *obj, const QVariantMap &properties);
 
-  // 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;
+    static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
 
-  // containg a list of argtypes for fast access
-  QHash<const QMetaObject *, ExtendedMetaObject *> _extendedMetaObjects;
+    QSet<AbstractPeer *> _peers;
 
-  // we use one SignalRelay per QObject
-  QHash<QObject*, SignalRelay *> _relayHash;
+    // containg a list of argtypes for fast access
+    QHash<const QMetaObject *, ExtendedMetaObject *> _extendedMetaObjects;
 
-  // RPC function -> (object, slot ID)
-  typedef QPair<QObject*, int> MethodId;
-  typedef QMultiHash<QByteArray, MethodId> SlotHash;
-  SlotHash _attachedSlots;
+    // SignalRelay for all manually attached signals
+    SignalRelay *_signalRelay;
 
-  // slaves for sync
-  typedef QHash<QString, SyncableObject *> ObjectId;
-  QHash<QByteArray, ObjectId> _syncSlave;
+    // 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;
-  QTimer _heartBeatTimer;
+    ProxyMode _proxyMode;
+    int _heartBeatInterval;
+    int _maxHeartBeatCount;
 
-  bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
+    bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
 
-  friend class SignalRelay;
+    friend class SignalRelay;
+    friend class SyncableObject;
+    friend class InternalPeer;
+    friend class RemotePeer;
 };
 
 
 // ==================================================
 //  ExtendedMetaObject
 // ==================================================
-class SignalProxy::ExtendedMetaObject {
+class SignalProxy::ExtendedMetaObject
+{
+    class MethodDescriptor
+    {
+    public:
+        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:
+        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.
+    };
+
+
 public:
-  ExtendedMetaObject(const QMetaObject *meta);
+    ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts);
+
+    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(); }
 
-  const QList<int> &argTypes(int methodId);
-  const int &returnType(int methodId);
-  const int &minArgCount(int methodId);
-  const QByteArray &methodName(int methodId);
-  const QHash<QByteArray, int> &syncMap();
-  const QHash<int, int> &receiveMap();
-  int updatedRemotelyId();
+    inline int methodId(const QByteArray &methodName) { return _methodIds.contains(methodName) ? _methodIds[methodName] : -1; }
 
-  static QByteArray methodName(const QMetaMethod &method);
-  static bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot);
-  static QString methodBaseName(const QMetaMethod &method);
+    inline int updatedRemotelyId() { return _updatedRemotelyId; }
+
+    inline const QHash<QByteArray, int> &slotMap() { return _methodIds; }
+    const QHash<int, int> &receiveMap();
+
+    const QMetaObject *metaObject() const { return _meta; }
+
+    static QByteArray methodName(const QMetaMethod &method);
+    static QString methodBaseName(const QMetaMethod &method);
 
 private:
-  typedef QHash<int, QList<int> > ArgHash;
-  typedef QHash<int, QByteArray> MethodNameHash;
-
-  const QMetaObject *_meta;
-  ArgHash _argTypes;
-  QHash<int, int> _returnType;
-  QHash<int, int> _minArgCount;
-  MethodNameHash _methodNames;
-  int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
-  QHash<QByteArray, int> _syncMap;
-  QHash<int, int> _receiveMap;
+    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
 };
 
 
 // ==================================================
-//  Peers
+//  AbstractPeer
 // ==================================================
-class SignalProxy::AbstractPeer {
-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;
-private:
-  PeerType _type;
-};
+class SignalProxy::AbstractPeer : public QObject
+{
+    Q_OBJECT
 
-class SignalProxy::IODevicePeer : public SignalProxy::AbstractPeer {
-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); }
-private:
-  QIODevice *_device;
-  quint32 byteCount;
-  bool usesCompression;
 public:
-  int sentHeartBeats;
-  int lag;
-};
+    AbstractPeer(QObject *parent = 0) : QObject(parent) {}
 
-class SignalProxy::SignalProxyPeer : public SignalProxy::AbstractPeer {
-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; }
-private:
-  SignalProxy *sender;
-  SignalProxy *receiver;
+    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