X-Git-Url: https://git.quassel-irc.org/?a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.h;h=645157ef84b6a8778f8bf1161bbd32e17b229d3a;hb=0e1b154f362e13c2c9009f842e3fd6d8e7c346fc;hp=b787c2ad5d03e01029925abd32dfbe9f06324890;hpb=4bd0fcd5b0599f3658253353bf2bdc01b32951f7;p=quassel.git

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index b787c2ad..645157ef 100644
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-07 by the Quassel IRC Team                         *
+ *   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,147 +15,331 @@
  *   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_
+#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;
-class QMetaObject;
+class SyncableObject;
+struct QMetaObject;
 
-class SignalProxy : public QObject {
-  Q_OBJECT
+class SignalProxy : public QObject
+{
+    Q_OBJECT
+
+    class SignalRelay;
 
 public:
-  enum ProxyMode {
-    Server,
-    Client
-  };
-
-  enum RequestType {
-    Sync = 0,
-    InitRequest,
-    InitData
-  };
-
-  SignalProxy(QObject *parent);
-  SignalProxy(ProxyMode mode, QObject *parent);
-  SignalProxy(ProxyMode mode, QIODevice *device, QObject *parent);
-  virtual ~SignalProxy();
-
-  void setProxyMode(ProxyMode mode);
-  ProxyMode proxyMode() const;
-
-  bool addPeer(QIODevice *iodev);
-  void removePeer(QIODevice *iodev = 0);
-
-  bool attachSignal(QObject *sender, const char *signal, const QByteArray& sigName = QByteArray());
-  bool attachSlot(const QByteArray& sigName, QObject *recv, const char *slot);
-
-  void synchronize(QObject *obj);
-  void synchronizeAsMaster(QObject *obj);
-  void synchronizeAsSlave(QObject *obj);
-
-  void setInitialized(QObject *obj);
-  bool initialized(QObject *obj);
-  void requestInit(QObject *obj);
-  
-  void detachObject(QObject *obj);
-  void detachSignals(QObject *sender);
-  void detachSlots(QObject *receiver);
-  
-  static void writeDataToDevice(QIODevice *dev, const QVariant &item);
-  static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item);
-
-  static QString methodBaseName(const QMetaMethod &method);
-  
-  const QList<int> &argTypes(QObject *obj, int methodId);
-  const QByteArray &methodName(QObject *obj, int methodId);
-  const QHash<int, int> &syncMap(QObject *obj);
-
-  typedef QHash<int, QList<int> > ArgHash;
-  typedef QHash<int, QByteArray> MethodNameHash;
-  struct ClassInfo {
-    ArgHash argTypes;
-    MethodNameHash methodNames;
-    QHash<int, int> syncMap;
-  };
-
-  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);
+
+protected:
+    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(QString oldname, QString newname);
-  void objectRenamed(QByteArray classname, QString oldname, QString newname);
+    void removePeerBySender();
+    void objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname);
+    void updateSecureState();
+
+signals:
+    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:
+    template<class T>
+    class PeerMessageEvent;
+
+    void init();
+    void initServer();
+    void initClient();
+
+    static const QMetaObject *metaObject(const QObject *obj);
+
+    void removePeer(AbstractPeer *peer);
+    void removeAllPeers();
+
+    template<class T>
+    void dispatch(const T &protoMessage);
+
+    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);
+
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
+
+    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:
+        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, 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(); }
+
+    inline int methodId(const QByteArray &methodName) { return _methodIds.contains(methodName) ? _methodIds[methodName] : -1; }
+
+    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:
+    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
+};
+
+
+// ==================================================
+//  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 QString errorString() const { return QString(); }
+
+    virtual int lag() const = 0;
+
+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;
+
+    virtual void close(const QString &reason = QString()) = 0;
 
 signals:
-  void peerRemoved(QIODevice *obj);
-  void connected();
-  void disconnected();
-  
+    void disconnected();
+    void error(QAbstractSocket::SocketError);
+    void secureStateChanged(bool secure = true);
+    void lagUpdated(int msecs);
+};
+
+
+// ==================================================
+//  Protocol Messages
+// ==================================================
+class SignalProxy::SyncMessage
+{
+public:
+    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:
+    QByteArray _className;
+    QString _objectName;
+    QByteArray _slotName;
+    QVariantList _params;
+};
+
+
+class SignalProxy::RpcCall
+{
+public:
+    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:
+    QByteArray _slotName;
+    QVariantList _params;
+};
+
+
+class SignalProxy::InitRequest
+{
+public:
+    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::InitData
+{
+public:
+    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:
-  void initServer();
-  void initClient();
-  
-  void createClassInfo(QObject *obj);
-  void setArgTypes(QObject *obj, int methodId);
-  void setMethodName(QObject *obj, int methodId);
-  void setSyncMap(QObject *obj);
-
-  bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const;
-
-  void dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList &params);
-  void dispatchSignal(const QVariant &identifier, const QVariantList &params);
-  
-  void receivePeerSignal(QIODevice *sender, const QVariant &packedFunc);
-  void handleSync(QVariantList params);
-  void handleInitRequest(QIODevice *sender, const QVariantList &params);
-  void handleInitData(QIODevice *sender, const QVariantList &params);
-  void handleSignal(const QByteArray &funcName, const QVariantList &params);
-
-  bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params);
-
-  QVariantMap initData(QObject *obj) const;
-  void setInitData(QObject *obj, const QVariantMap &properties);
-  bool setInitValue(QObject *obj, const QString &property, const QVariant &value);
-
-  void _detachSignals(QObject *sender);
-  void _detachSlots(QObject *receiver);
-
-    void dumpSyncMap(QObject *object);
-  
-  // containg a list of argtypes for fast access
-  QHash<const QMetaObject *, ClassInfo*> _classInfo;
-
-  // we use one SignalRelay per QObject
-  QHash<QObject*, SignalRelay *> _relayHash;
-
-  // RPC function -> (object, slot ID)
-  typedef QPair<QObject*, int> MethodId;
-  typedef QMultiHash<QByteArray, MethodId> SlotHash;
-  SlotHash _attachedSlots;
-
-  // slaves for sync
-  typedef QHash<QString, QObject *> ObjectId;
-  QHash<QByteArray, ObjectId> _syncSlave;
-
-  // Hash of used QIODevices
-  QHash<QIODevice*, quint32> _peerByteCount;
-
-  ProxyMode _proxyMode;
-  
-  friend class SignalRelay;
+    QByteArray _className;
+    QString _objectName;
+    QVariantMap _initData;
 };
 
 #endif