File indexing completed on 2024-11-17 04:45:06

 /*
     SPDX-FileCopyrightText: 2007 Till Adam <adam@kde.org>
     SPDX-FileCopyrightText: 2008 Omat Holding B.V. <info@omat.nl>
     SPDX-FileCopyrightText: 2009 Kevin Ottens <ervin@kde.org>
 
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
     SPDX-FileContributor: Kevin Ottens <kevin@kdab.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "imapidlemanager.h"
 
 #include "imapresource_debug.h"
 
 #include <KIMAP/IdleJob>
 #include <KIMAP/SelectJob>
 #include <KIMAP/Session>
 
 #include <QTimer>
 
 #include "imapresource.h"
 #include "sessionpool.h"
 
 #include <chrono>
 
 namespace
 {
 // RFC2177 says clients should restart IDLE every 29 minutes, as
 // servers MAY consider clients inactive after 30 minutes.
 // TODO: Make configurable to support less RF-conformant servers
 static const auto IdleTimeout = std::chrono::minutes(29);
 }
 
 ImapIdleManager::ImapIdleManager(ResourceStateInterface::Ptr state, SessionPool *pool, ImapResourceBase *parent)
     : QObject(parent)
     , m_sessionRequestId(0)
     , m_pool(pool)
     , m_resource(parent)
     , m_state(state)
     , m_lastMessageCount(-1)
     , m_lastRecentCount(-1)
 {
     connect(pool, &SessionPool::sessionRequestDone, this, &ImapIdleManager::onSessionRequestDone);
     m_sessionRequestId = m_pool->requestSession();
 
     m_idleTimeout = new QTimer(this);
     m_idleTimeout->setSingleShot(true);
     connect(m_idleTimeout, &QTimer::timeout, this, &ImapIdleManager::restartIdle);
 }
 
 ImapIdleManager::~ImapIdleManager()
 {
     stop();
     if (m_pool) {
         if (m_sessionRequestId) {
             m_pool->cancelSessionRequest(m_sessionRequestId);
         }
         if (m_session) {
             m_pool->releaseSession(m_session);
         }
     }
 }
 
 void ImapIdleManager::stop()
 {
     m_idleTimeout->stop();
     if (m_idle) {
         m_idle->stop();
         disconnect(m_idle, nullptr, this, nullptr);
         m_idle = nullptr;
     }
     if (m_pool) {
         disconnect(m_pool, nullptr, this, nullptr);
     }
 }
 
 KIMAP::Session *ImapIdleManager::session() const
 {
     return m_session;
 }
 
 void ImapIdleManager::reconnect()
 {
     qCDebug(IMAPRESOURCE_LOG) << "attempting to reconnect IDLE session";
     if (m_session == nullptr && m_pool->isConnected() && m_sessionRequestId == 0) {
         m_sessionRequestId = m_pool->requestSession();
     }
 }
 
 void ImapIdleManager::onSessionRequestDone(qint64 requestId, KIMAP::Session *session, int errorCode, const QString & /*errorString*/)
 {
     if (requestId != m_sessionRequestId || session == nullptr || errorCode != SessionPool::NoError) {
         return;
     }
 
     m_session = session;
     m_sessionRequestId = 0;
 
     connect(m_pool, &SessionPool::connectionLost, this, &ImapIdleManager::onConnectionLost);
     connect(m_pool, &SessionPool::disconnectDone, this, &ImapIdleManager::onPoolDisconnect);
 
     startIdle();
 }
 
 void ImapIdleManager::startIdle()
 {
     const auto idleMailBox = m_state->mailBoxForCollection(m_state->collection());
     if (m_session->selectedMailBox() != idleMailBox) {
         auto select = new KIMAP::SelectJob(m_session);
         select->setMailBox(idleMailBox);
         connect(select, &KIMAP::SelectJob::result, this, &ImapIdleManager::onSelectDone);
         select->start();
     }
 
     m_idle = new KIMAP::IdleJob(m_session);
     connect(m_idle.data(), &KIMAP::IdleJob::mailBoxStats, this, &ImapIdleManager::onStatsReceived);
     connect(m_idle.data(), &KIMAP::IdleJob::mailBoxMessageFlagsChanged, this, &ImapIdleManager::onFlagsChanged);
     connect(m_idle.data(), &KIMAP::IdleJob::result, this, &ImapIdleManager::onIdleStopped);
     m_idle->start();
     m_idleTimeout->start(std::chrono::milliseconds(IdleTimeout).count());
 }
 
 void ImapIdleManager::restartIdle()
 {
     qCDebug(IMAPRESOURCE_LOG) << "Restarting IDLE to prevent server from disconnecting me!";
     if (m_idle) {
         m_idle->stop(); // this will invoke onIdleStopped(), which will automatically reconnect
     }
 }
 
 void ImapIdleManager::onConnectionLost(KIMAP::Session *session)
 {
     if (session == m_session) {
         // Our session becomes invalid, so get ride of
         // the pointer, we don't need to release it once the
         // task is done
         m_session = nullptr;
         QMetaObject::invokeMethod(this, &ImapIdleManager::reconnect, Qt::QueuedConnection);
     }
 }
 
 void ImapIdleManager::onPoolDisconnect()
 {
     // All the sessions in the pool we used changed,
     // so get ride of the pointer, we don't need to
     // release our session anymore
     m_pool = nullptr;
 }
 
 void ImapIdleManager::onSelectDone(KJob *job)
 {
     auto select = static_cast<KIMAP::SelectJob *>(job);
 
     m_lastMessageCount = select->messageCount();
     m_lastRecentCount = select->recentCount();
 }
 
 void ImapIdleManager::onIdleStopped()
 {
     qCDebug(IMAPRESOURCE_LOG) << "IDLE dropped maybe we should reconnect?";
     m_idle = nullptr;
     if (m_session) {
         qCDebug(IMAPRESOURCE_LOG) << "Restarting the IDLE session!";
         startIdle();
     }
 }
 
 void ImapIdleManager::onStatsReceived(KIMAP::IdleJob *job, const QString &mailBox, int messageCount, int recentCount)
 {
     qCDebug(IMAPRESOURCE_LOG) << "IDLE stats received:" << job << mailBox << messageCount << recentCount;
     qCDebug(IMAPRESOURCE_LOG) << "Cached information:" << m_state->collection().remoteId() << m_state->collection().id() << m_lastMessageCount
                               << m_lastRecentCount;
 
     // It seems we're not in sync with the cache, resync is needed
     if (messageCount != m_lastMessageCount || recentCount != m_lastRecentCount) {
         m_lastMessageCount = messageCount;
         m_lastRecentCount = recentCount;
 
         qCDebug(IMAPRESOURCE_LOG) << "Resync needed for" << mailBox << m_state->collection().id();
         m_resource->synchronizeCollection(m_state->collection().id());
     }
 }
 
 void ImapIdleManager::onFlagsChanged(KIMAP::IdleJob *job)
 {
     Q_UNUSED(job)
     qCDebug(IMAPRESOURCE_LOG) << "IDLE flags changed in" << m_session->selectedMailBox();
     m_resource->synchronizeCollection(m_state->collection().id());
 }
 
 #include "moc_imapidlemanager.cpp"