X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fsessionthread.cpp;h=d8e8c4dbca720a467276f27b4883e51763150c9e;hp=d5070955485dbbf7247f363dda731571f9365c4f;hb=edc55b1f86cf613a332eeeb5d85537a54120dfa5;hpb=d1b6499b0b848d4287efae89107576548533502c

diff --git a/src/core/sessionthread.cpp b/src/core/sessionthread.cpp
index d5070955..d8e8c4db 100644
--- a/src/core/sessionthread.cpp
+++ b/src/core/sessionthread.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-08 by the Quassel IRC Team                         *
+ *   Copyright (C) 2005-2019 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -15,69 +15,137 @@
  *   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.         *
  ***************************************************************************/
 
-#include <QMutexLocker>
-
 #include "sessionthread.h"
 
+#include <QPointer>
+#include <QTimer>
+
+#include "core.h"
 #include "coresession.h"
+#include "internalpeer.h"
+#include "remotepeer.h"
+#include "signalproxy.h"
 
-SessionThread::SessionThread(UserId uid, QObject *parent) : QThread(parent) {
-    _user = uid;
-    _session = 0;
-    _sessionInitialized = false;
-    connect(this, SIGNAL(initialized()), this, SLOT(setSessionInitialized()));
-}
+namespace {
 
-SessionThread::~SessionThread() {
-  // FIXME
-  quit();
-  wait();
-  if(session()) _session->deleteLater();
-}
+class Worker : public QObject
+{
+    Q_OBJECT
 
-CoreSession *SessionThread::session() {
-  return _session;
-}
+public:
+    Worker(UserId userId, bool restoreState, bool strictIdentEnabled)
+        : _userId{userId}
+        , _restoreState{restoreState}
+        , _strictIdentEnabled{strictIdentEnabled}
+    {}
+
+public slots:
+    void initialize()
+    {
+        _session = new CoreSession{_userId, _restoreState, _strictIdentEnabled, this};
+        connect(_session, &QObject::destroyed, QThread::currentThread(), &QThread::quit);
+        connect(_session, &CoreSession::sessionStateReceived, Core::instance(), &Core::sessionStateReceived);
+        emit initialized();
+    }
+
+    void shutdown()
+    {
+        if (_session) {
+            _session->shutdown();
+        }
+    }
+
+    void addClient(Peer* peer)
+    {
+        if (!_session) {
+            qWarning() << "Session not initialized!";
+            return;
+        }
+
+        auto remotePeer = qobject_cast<RemotePeer*>(peer);
+        if (remotePeer) {
+            _session->addClient(remotePeer);
+            return;
+        }
+        auto internalPeer = qobject_cast<InternalPeer*>(peer);
+        if (internalPeer) {
+            _session->addClient(internalPeer);
+            return;
+        }
+
+        qWarning() << "SessionThread::addClient() received invalid peer!" << peer;
+    }
+
+signals:
+    void initialized();
+
+private:
+    UserId _userId;
+    bool _restoreState;
+    bool _strictIdentEnabled;  ///< Whether or not strict ident mode is enabled, locking users' idents to Quassel username
+    QPointer<CoreSession> _session;
+};
+
+}  // namespace
+
+SessionThread::SessionThread(UserId uid, bool restoreState, bool strictIdentEnabled, QObject* parent)
+    : QObject(parent)
+{
+    auto worker = new Worker(uid, restoreState, strictIdentEnabled);
+    worker->moveToThread(&_sessionThread);
+    connect(&_sessionThread, &QThread::started, worker, &Worker::initialize);
+    connect(&_sessionThread, &QThread::finished, worker, &QObject::deleteLater);
+    connect(worker, &Worker::initialized, this, &SessionThread::onSessionInitialized);
+    connect(worker, &QObject::destroyed, this, &SessionThread::onSessionDestroyed);
+
+    connect(this, &SessionThread::addClientToWorker, worker, &Worker::addClient);
+    connect(this, &SessionThread::shutdownSession, worker, &Worker::shutdown);
 
-UserId SessionThread::user() {
-  return _user;
+    // Defer thread start through the event loop, so the SessionThread instance is fully constructed before
+    QTimer::singleShot(0, &_sessionThread, SLOT(start()));
 }
 
-bool SessionThread::isSessionInitialized() {
-  return _sessionInitialized;
+SessionThread::~SessionThread()
+{
+    // shut down thread gracefully
+    _sessionThread.quit();
+    _sessionThread.wait(30000);
 }
 
-void SessionThread::setSessionInitialized() {
-  _sessionInitialized = true;
-  foreach(QIODevice *socket, clientQueue) {
-    addClientToSession(socket);
-  }
-  clientQueue.clear();
+void SessionThread::shutdown()
+{
+    emit shutdownSession();
 }
 
-void SessionThread::addClient(QIODevice *socket) {
-  if(isSessionInitialized()) {
-    addClientToSession(socket);
-  } else {
-    clientQueue.append(socket);
-  }
+void SessionThread::onSessionInitialized()
+{
+    _sessionInitialized = true;
+    for (auto&& peer : _clientQueue) {
+        peer->setParent(nullptr);
+        peer->moveToThread(&_sessionThread);
+        emit addClientToWorker(peer);
+    }
+    _clientQueue.clear();
 }
 
-void SessionThread::addClientToSession(QIODevice *socket) {
-  socket->setParent(0);
-  socket->moveToThread(session()->thread());
-  if(!QMetaObject::invokeMethod(session(), "addClient", Q_ARG(QObject *, socket))) {
-    qWarning() << qPrintable(tr("Could not initialize session!"));
-    socket->close();
-  }
+void SessionThread::onSessionDestroyed()
+{
+    emit shutdownComplete(this);
 }
 
-void SessionThread::run() {
-  _session = new CoreSession(user());
-  emit initialized();
-  exec();
+void SessionThread::addClient(Peer* peer)
+{
+    if (_sessionInitialized) {
+        peer->setParent(nullptr);
+        peer->moveToThread(&_sessionThread);
+        emit addClientToWorker(peer);
+    }
+    else {
+        _clientQueue.push_back(peer);
+    }
 }
 
+#include "sessionthread.moc"