src/common/internalpeer.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2018 by the Quassel Project                        *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include <QCoreApplication>
  22 #include <QThread>
  23
  24 #include "internalpeer.h"
  25
  26 using namespace Protocol;
  27
  28 template<class T>
  29 class PeerMessageEvent : public QEvent
  30 {
  31 public:
  32     PeerMessageEvent(InternalPeer *sender, InternalPeer::EventType eventType, const T &message)
  33         : QEvent(QEvent::Type(eventType)), sender(sender), message(message)
  34     {}
  35
  36     InternalPeer *sender;
  37     T message;
  38 };
  39
  40
  41 InternalPeer::InternalPeer(QObject *parent)
  42     : Peer(0, parent),
  43     _proxy(0),
  44     _peer(0),
  45     _isOpen(true)
  46 {
  47     setFeatures(Quassel::Features{});
  48 }
  49
  50
  51 InternalPeer::~InternalPeer()
  52 {
  53     if (_isOpen)
  54         emit disconnected();
  55 }
  56
  57
  58 QString InternalPeer::description() const
  59 {
  60     return tr("internal connection");
  61 }
  62
  63 QString InternalPeer::address() const
  64 {
  65     return tr("internal connection");
  66 }
  67
  68 quint16 InternalPeer::port() const
  69 {
  70     return 0;
  71 }
  72
  73 bool InternalPeer::isOpen() const
  74 {
  75     return true;
  76 }
  77
  78
  79 bool InternalPeer::isSecure() const
  80 {
  81     return true;
  82 }
  83
  84
  85 bool InternalPeer::isLocal() const
  86 {
  87     return true;
  88 }
  89
  90
  91 void InternalPeer::close(const QString &reason)
  92 {
  93     // FIXME
  94     Q_UNUSED(reason)
  95     qWarning() << "closing not implemented!";
  96 }
  97
  98
  99 int InternalPeer::lag() const
 100 {
 101     return 0;
 102 }
 103
 104
 105 ::SignalProxy *InternalPeer::signalProxy() const
 106 {
 107     return _proxy;
 108 }
 109
 110
 111 void InternalPeer::setSignalProxy(::SignalProxy *proxy)
 112 {
 113     if (!proxy && _proxy) {
 114         _proxy = 0;
 115         if (_isOpen) {
 116             _isOpen = false;
 117             emit disconnected();
 118         }
 119         return;
 120     }
 121
 122     if (proxy && !_proxy) {
 123         _proxy = proxy;
 124         return;
 125     }
 126
 127     qWarning() << Q_FUNC_INFO << "Changing the SignalProxy is not supported!";
 128 }
 129
 130
 131 void InternalPeer::setPeer(InternalPeer *peer)
 132 {
 133     if (_peer) {
 134         qWarning() << Q_FUNC_INFO << "Peer already set, ignoring!";
 135         return;
 136     }
 137     _peer = peer;
 138     connect(peer, SIGNAL(disconnected()), SLOT(peerDisconnected()));
 139 }
 140
 141
 142 void InternalPeer::peerDisconnected()
 143 {
 144     disconnect(_peer, 0, this, 0);
 145     _peer = 0;
 146     if (_isOpen) {
 147         _isOpen = false;
 148         emit disconnected();
 149     }
 150 }
 151
 152
 153 void InternalPeer::dispatch(const SyncMessage &msg)
 154 {
 155     dispatch(SyncMessageEvent, msg);
 156 }
 157
 158
 159 void InternalPeer::dispatch(const RpcCall &msg)
 160 {
 161     dispatch(RpcCallEvent, msg);
 162 }
 163
 164
 165 void InternalPeer::dispatch(const InitRequest &msg)
 166 {
 167     dispatch(InitRequestEvent, msg);
 168 }
 169
 170
 171 void InternalPeer::dispatch(const InitData &msg)
 172 {
 173     dispatch(InitDataEvent, msg);
 174 }
 175
 176
 177 namespace {
 178
 179 void setSourcePeer(Peer* peer)
 180 {
 181     auto p = SignalProxy::current();
 182     if (p)
 183         p->setSourcePeer(peer);
 184 }
 185
 186 }  // anon
 187
 188
 189 template<class T>
 190 void InternalPeer::dispatch(EventType eventType, const T &msg)
 191 {
 192     if (!_peer) {
 193         qWarning() << Q_FUNC_INFO << "Cannot dispatch a message without a peer!";
 194         return;
 195     }
 196
 197     // The peers always live in different threads, so use an event for thread-safety
 198     QCoreApplication::postEvent(_peer, new PeerMessageEvent<T>(this, eventType, msg));
 199 }
 200
 201
 202 void InternalPeer::customEvent(QEvent *event)
 203 {
 204     setSourcePeer(this);
 205
 206     switch ((int)event->type()) {
 207         case SyncMessageEvent: {
 208             handle(static_cast<PeerMessageEvent<SyncMessage> *>(event)->message);
 209             break;
 210         }
 211         case RpcCallEvent: {
 212             handle(static_cast<PeerMessageEvent<RpcCall> *>(event)->message);
 213             break;
 214         }
 215         case InitRequestEvent: {
 216             handle(static_cast<PeerMessageEvent<InitRequest> *>(event)->message);
 217             break;
 218         }
 219         case InitDataEvent: {
 220             handle(static_cast<PeerMessageEvent<InitData> *>(event)->message);
 221             break;
 222         }
 223
 224         default:
 225             qWarning() << Q_FUNC_INFO << "Received unknown custom event:" << event->type();
 226             setSourcePeer(nullptr);
 227             return;
 228     }
 229
 230     setSourcePeer(nullptr);
 231     event->accept();
 232 }