File indexing completed on 2024-11-10 04:40:31

 /*
     SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "specialcollectionshelperjobs_p.h"
 
 #include "servermanager.h"
 #include "specialcollectionattribute.h"
 #include <QDBusConnection>
 
 #include "agentinstance.h"
 #include "agentinstancecreatejob.h"
 #include "agentmanager.h"
 #include "collectionfetchjob.h"
 #include "collectionfetchscope.h"
 #include "collectionmodifyjob.h"
 #include "entitydisplayattribute.h"
 #include "resourcesynchronizationjob.h"
 
 #include "akonadicore_debug.h"
 
 #include <KCoreConfigSkeleton>
 #include <KLocalizedString>
 
 #include <QDBusConnectionInterface>
 #include <QDBusInterface>
 #include <QDBusServiceWatcher>
 #include <QMetaMethod>
 #include <QTime>
 #include <QTimer>
 
 #define LOCK_WAIT_TIMEOUT_SECONDS 30
 
 using namespace Akonadi;
 
 // convenient methods to get/set the default resource id
 static void setDefaultResourceId(KCoreConfigSkeleton *settings, const QString &value)
 {
     KConfigSkeletonItem *item = settings->findItem(QStringLiteral("DefaultResourceId"));
     Q_ASSERT(item);
     item->setProperty(value);
 }
 
 static QString defaultResourceId(KCoreConfigSkeleton *settings)
 {
     const KConfigSkeletonItem *item = settings->findItem(QStringLiteral("DefaultResourceId"));
     Q_ASSERT(item);
     return item->property().toString();
 }
 
 static QString dbusServiceName()
 {
     const QString service = QStringLiteral("org.kde.pim.SpecialCollections");
     if (ServerManager::hasInstanceIdentifier()) {
         return service + ServerManager::instanceIdentifier();
     }
     return service;
 }
 
 static QMetaType::Type argumentType(const QMetaObject *metaObject, const QString &method)
 {
     QMetaMethod metaMethod;
     for (int i = 0; i < metaObject->methodCount(); ++i) {
         const QString signature = QString::fromLatin1(metaObject->method(i).methodSignature());
         if (signature.startsWith(method)) {
             metaMethod = metaObject->method(i);
         }
     }
 
     if (metaMethod.methodSignature().isEmpty()) {
         return QMetaType::UnknownType;
     }
 
     const QList<QByteArray> argTypes = metaMethod.parameterTypes();
     if (argTypes.count() != 1) {
         return QMetaType::UnknownType;
     }
 
     return static_cast<QMetaType::Type>(QMetaType::fromName(argTypes.first().constData()).id());
 }
 
 // ===================== ResourceScanJob ============================
 
 /**
   @internal
 */
 class Akonadi::ResourceScanJobPrivate
 {
 public:
     ResourceScanJobPrivate(KCoreConfigSkeleton *settings, ResourceScanJob *qq);
 
     void fetchResult(KJob *job); // slot
 
     ResourceScanJob *const q;
 
     // Input:
     QString mResourceId;
     KCoreConfigSkeleton *mSettings = nullptr;
 
     // Output:
     Collection mRootCollection;
     Collection::List mSpecialCollections;
 };
 
 ResourceScanJobPrivate::ResourceScanJobPrivate(KCoreConfigSkeleton *settings, ResourceScanJob *qq)
     : q(qq)
     , mSettings(settings)
 {
 }
 
 void ResourceScanJobPrivate::fetchResult(KJob *job)
 {
     if (job->error()) {
         qCWarning(AKONADICORE_LOG) << job->errorText();
         return;
     }
 
     auto fetchJob = qobject_cast<CollectionFetchJob *>(job);
     Q_ASSERT(fetchJob);
 
     Q_ASSERT(!mRootCollection.isValid());
     Q_ASSERT(mSpecialCollections.isEmpty());
     const Akonadi::Collection::List lstCols = fetchJob->collections();
     for (const Collection &collection : lstCols) {
         if (collection.parentCollection() == Collection::root()) {
             if (mRootCollection.isValid()) {
                 qCWarning(AKONADICORE_LOG) << "Resource has more than one root collection. I don't know what to do.";
             } else {
                 mRootCollection = collection;
             }
         }
 
         if (collection.hasAttribute<SpecialCollectionAttribute>()) {
             mSpecialCollections.append(collection);
         }
     }
 
     qCDebug(AKONADICORE_LOG) << "Fetched root collection" << mRootCollection.id() << "and" << mSpecialCollections.count() << "local folders"
                              << "(total" << fetchJob->collections().count() << "collections).";
 
     if (!mRootCollection.isValid()) {
         q->setError(ResourceScanJob::Unknown);
         q->setErrorText(i18n("Could not fetch root collection of resource %1.", mResourceId));
         q->emitResult();
         return;
     }
 
     // We are done!
     q->emitResult();
 }
 
 ResourceScanJob::ResourceScanJob(const QString &resourceId, KCoreConfigSkeleton *settings, QObject *parent)
     : Job(parent)
     , d(new ResourceScanJobPrivate(settings, this))
 {
     setResourceId(resourceId);
 }
 
 ResourceScanJob::~ResourceScanJob() = default;
 
 QString ResourceScanJob::resourceId() const
 {
     return d->mResourceId;
 }
 
 void ResourceScanJob::setResourceId(const QString &resourceId)
 {
     d->mResourceId = resourceId;
 }
 
 Akonadi::Collection ResourceScanJob::rootResourceCollection() const
 {
     return d->mRootCollection;
 }
 
 Akonadi::Collection::List ResourceScanJob::specialCollections() const
 {
     return d->mSpecialCollections;
 }
 
 void ResourceScanJob::doStart()
 {
     if (d->mResourceId.isEmpty()) {
         if (!qobject_cast<DefaultResourceJob *>(this)) {
             qCCritical(AKONADICORE_LOG) << "No resource ID given.";
             setError(Job::Unknown);
             setErrorText(i18n("No resource ID given."));
         }
         emitResult();
         return;
     }
 
     auto fetchJob = new CollectionFetchJob(Collection::root(), CollectionFetchJob::Recursive, this);
     fetchJob->fetchScope().setResource(d->mResourceId);
     fetchJob->fetchScope().setIncludeStatistics(true);
     fetchJob->fetchScope().setListFilter(CollectionFetchScope::Display);
     connect(fetchJob, &CollectionFetchJob::result, this, [this](KJob *job) {
         d->fetchResult(job);
     });
 }
 
 // ===================== DefaultResourceJob ============================
 
 /**
   @internal
 */
 class Akonadi::DefaultResourceJobPrivate
 {
 public:
     DefaultResourceJobPrivate(KCoreConfigSkeleton *settings, DefaultResourceJob *qq);
 
     void tryFetchResource();
     void resourceCreateResult(KJob *job); // slot
     void resourceSyncResult(KJob *job); // slot
     void collectionFetchResult(KJob *job); // slot
     void collectionModifyResult(KJob *job); // slot
 
     DefaultResourceJob *const q;
     KCoreConfigSkeleton *mSettings = nullptr;
     QVariantMap mDefaultResourceOptions;
     QList<QByteArray> mKnownTypes;
     QMap<QByteArray, QString> mNameForTypeMap;
     QMap<QByteArray, QString> mIconForTypeMap;
     QString mDefaultResourceType;
     int mPendingModifyJobs = 0;
     bool mResourceWasPreexisting = true;
 };
 
 DefaultResourceJobPrivate::DefaultResourceJobPrivate(KCoreConfigSkeleton *settings, DefaultResourceJob *qq)
     : q(qq)
     , mSettings(settings)
     , mPendingModifyJobs(0)
     , mResourceWasPreexisting(true /* for safety, so as not to accidentally delete data */)
 {
 }
 
 void DefaultResourceJobPrivate::tryFetchResource()
 {
     // Get the resourceId from config. Another instance might have changed it in the meantime.
     mSettings->load();
 
     const QString resourceId = defaultResourceId(mSettings);
 
     qCDebug(AKONADICORE_LOG) << "Read defaultResourceId" << resourceId << "from config.";
 
     const AgentInstance resource = AgentManager::self()->instance(resourceId);
     if (resource.isValid()) {
         // The resource exists; scan it.
         mResourceWasPreexisting = true;
         qCDebug(AKONADICORE_LOG) << "Found resource" << resourceId;
         q->setResourceId(resourceId);
 
         auto fetchJob = new CollectionFetchJob(Collection::root(), CollectionFetchJob::Recursive, q);
         fetchJob->fetchScope().setResource(resourceId);
         fetchJob->fetchScope().setIncludeStatistics(true);
         q->connect(fetchJob, &CollectionFetchJob::result, q, [this](KJob *job) {
             collectionFetchResult(job);
         });
     } else {
         // Try harder: maybe the default resource has been removed and another one added
         //             without updating the config file, in this case search for a resource
         //             of the same type and the default name
         const AgentInstance::List resources = AgentManager::self()->instances();
         for (const AgentInstance &resourceInstance : resources) {
             if (resourceInstance.type().identifier() == mDefaultResourceType) {
                 if (resourceInstance.name() == mDefaultResourceOptions.value(QStringLiteral("Name")).toString()) {
                     // found a matching one...
                     setDefaultResourceId(mSettings, resourceInstance.identifier());
                     mSettings->save();
                     mResourceWasPreexisting = true;
                     qCDebug(AKONADICORE_LOG) << "Found resource" << resourceInstance.identifier();
                     q->setResourceId(resourceInstance.identifier());
                     q->ResourceScanJob::doStart();
                     return;
                 }
             }
         }
 
         // Create the resource.
         mResourceWasPreexisting = false;
         qCDebug(AKONADICORE_LOG) << "Creating maildir resource.";
         const AgentType type = AgentManager::self()->type(mDefaultResourceType);
         auto job = new AgentInstanceCreateJob(type, q);
         QObject::connect(job, &AgentInstanceCreateJob::result, q, [this](KJob *job) {
             resourceCreateResult(job);
         });
         job->start(); // non-Akonadi::Job
     }
 }
 
 void DefaultResourceJobPrivate::resourceCreateResult(KJob *job)
 {
     if (job->error()) {
         qCWarning(AKONADICORE_LOG) << job->errorText();
         // fail( i18n( "Failed to create the default resource (%1).", job->errorString() ) );
         q->setError(job->error());
         q->setErrorText(job->errorText());
         q->emitResult();
         return;
     }
 
     AgentInstance agent;
 
     // Get the resource instance.
     {
         auto createJob = qobject_cast<AgentInstanceCreateJob *>(job);
         Q_ASSERT(createJob);
         agent = createJob->instance();
         setDefaultResourceId(mSettings, agent.identifier());
         qCDebug(AKONADICORE_LOG) << "Created maildir resource with id" << defaultResourceId(mSettings);
     }
 
     const QString defaultId = defaultResourceId(mSettings);
 
     // Configure the resource.
     {
         agent.setName(mDefaultResourceOptions.value(QStringLiteral("Name")).toString());
 
         const auto service = ServerManager::agentServiceName(ServerManager::Resource, defaultId);
         QDBusInterface conf(service, QStringLiteral("/Settings"), QString());
 
         if (!conf.isValid()) {
             q->setError(-1);
             q->setErrorText(i18n("Invalid resource identifier '%1'", defaultId));
             q->emitResult();
             return;
         }
 
         QMap<QString, QVariant>::const_iterator it = mDefaultResourceOptions.cbegin();
         const QMap<QString, QVariant>::const_iterator itEnd = mDefaultResourceOptions.cend();
         for (; it != itEnd; ++it) {
             if (it.key() == QLatin1StringView("Name")) {
                 continue;
             }
 
             const QString methodName = QStringLiteral("set%1").arg(it.key());
             const QMetaType::Type argType = argumentType(conf.metaObject(), methodName);
             if (argType == QMetaType::UnknownType) {
                 q->setError(Job::Unknown);
                 q->setErrorText(i18n("Failed to configure default resource via D-Bus."));
                 q->emitResult();
                 return;
             }
 
             QDBusReply<void> reply = conf.call(methodName, it.value());
             if (!reply.isValid()) {
                 q->setError(Job::Unknown);
                 q->setErrorText(i18n("Failed to configure default resource via D-Bus."));
                 q->emitResult();
                 return;
             }
         }
 
         conf.call(QStringLiteral("save"));
 
         agent.reconfigure();
     }
 
     // Sync the resource.
     {
         auto syncJob = new ResourceSynchronizationJob(agent, q);
         QObject::connect(syncJob, &ResourceSynchronizationJob::result, q, [this](KJob *job) {
             resourceSyncResult(job);
         });
         syncJob->start(); // non-Akonadi
     }
 }
 
 void DefaultResourceJobPrivate::resourceSyncResult(KJob *job)
 {
     if (job->error()) {
         qCWarning(AKONADICORE_LOG) << job->errorText();
         // fail( i18n( "ResourceSynchronizationJob failed (%1).", job->errorString() ) );
         return;
     }
 
     // Fetch the collections of the resource.
     qCDebug(AKONADICORE_LOG) << "Fetching maildir collections.";
     auto fetchJob = new CollectionFetchJob(Collection::root(), CollectionFetchJob::Recursive, q);
     fetchJob->fetchScope().setResource(defaultResourceId(mSettings));
     QObject::connect(fetchJob, &CollectionFetchJob::result, q, [this](KJob *job) {
         collectionFetchResult(job);
     });
 }
 
 void DefaultResourceJobPrivate::collectionFetchResult(KJob *job)
 {
     if (job->error()) {
         qCWarning(AKONADICORE_LOG) << job->errorText();
         // fail( i18n( "Failed to fetch the root maildir collection (%1).", job->errorString() ) );
         return;
     }
 
     auto fetchJob = qobject_cast<CollectionFetchJob *>(job);
     Q_ASSERT(fetchJob);
 
     const Collection::List collections = fetchJob->collections();
     qCDebug(AKONADICORE_LOG) << "Fetched" << collections.count() << "collections.";
 
     // Find the root maildir collection.
     Collection::List toRecover;
     Collection resourceCollection;
     for (const Collection &collection : collections) {
         if (collection.parentCollection() == Collection::root()) {
             resourceCollection = collection;
             toRecover.append(collection);
             break;
         }
     }
 
     if (!resourceCollection.isValid()) {
         q->setError(Job::Unknown);
         q->setErrorText(i18n("Failed to fetch the resource collection."));
         q->emitResult();
         return;
     }
 
     // Find all children of the resource collection.
     for (const Collection &collection : std::as_const(collections)) {
         if (collection.parentCollection() == resourceCollection) {
             toRecover.append(collection);
         }
     }
 
     QHash<QString, QByteArray> typeForName;
     for (const QByteArray &type : std::as_const(mKnownTypes)) {
         const QString displayName = mNameForTypeMap.value(type);
         typeForName[displayName] = type;
     }
 
     // These collections have been created by the maildir resource, when it
     // found the folders on disk. So give them the necessary attributes now.
     Q_ASSERT(mPendingModifyJobs == 0);
     for (Collection collection : std::as_const(toRecover)) {
         if (collection.hasAttribute<SpecialCollectionAttribute>()) {
             continue;
         }
 
         // Find the type for the collection.
         const QString name = collection.displayName();
         const QByteArray type = typeForName.value(name);
 
         if (!type.isEmpty()) {
             qCDebug(AKONADICORE_LOG) << "Recovering collection" << name;
             setCollectionAttributes(collection, type, mNameForTypeMap, mIconForTypeMap);
 
             auto modifyJob = new CollectionModifyJob(collection, q);
             QObject::connect(modifyJob, &CollectionModifyJob::result, q, [this](KJob *job) {
                 collectionModifyResult(job);
             });
             mPendingModifyJobs++;
         } else {
             qCDebug(AKONADICORE_LOG) << "Searching for names: " << typeForName.keys();
             qCDebug(AKONADICORE_LOG) << "Unknown collection name" << name << "-- not recovering.";
         }
     }
 
     if (mPendingModifyJobs == 0) {
         // Scan the resource.
         q->setResourceId(defaultResourceId(mSettings));
         q->ResourceScanJob::doStart();
     }
 }
 
 void DefaultResourceJobPrivate::collectionModifyResult(KJob *job)
 {
     if (job->error()) {
         qCWarning(AKONADICORE_LOG) << job->errorText();
         // fail( i18n( "Failed to modify the root maildir collection (%1).", job->errorString() ) );
         return;
     }
 
     Q_ASSERT(mPendingModifyJobs > 0);
     mPendingModifyJobs--;
     qCDebug(AKONADICORE_LOG) << "pendingModifyJobs now" << mPendingModifyJobs;
     if (mPendingModifyJobs == 0) {
         // Write the updated config.
         qCDebug(AKONADICORE_LOG) << "Writing defaultResourceId" << defaultResourceId(mSettings) << "to config.";
         mSettings->save();
 
         // Scan the resource.
         q->setResourceId(defaultResourceId(mSettings));
         q->ResourceScanJob::doStart();
     }
 }
 
 DefaultResourceJob::DefaultResourceJob(KCoreConfigSkeleton *settings, QObject *parent)
     : ResourceScanJob(QString(), settings, parent)
     , d(new DefaultResourceJobPrivate(settings, this))
 {
 }
 
 DefaultResourceJob::~DefaultResourceJob() = default;
 
 void DefaultResourceJob::setDefaultResourceType(const QString &type)
 {
     d->mDefaultResourceType = type;
 }
 
 void DefaultResourceJob::setDefaultResourceOptions(const QVariantMap &options)
 {
     d->mDefaultResourceOptions = options;
 }
 
 void DefaultResourceJob::setTypes(const QList<QByteArray> &types)
 {
     d->mKnownTypes = types;
 }
 
 void DefaultResourceJob::setNameForTypeMap(const QMap<QByteArray, QString> &map)
 {
     d->mNameForTypeMap = map;
 }
 
 void DefaultResourceJob::setIconForTypeMap(const QMap<QByteArray, QString> &map)
 {
     d->mIconForTypeMap = map;
 }
 
 void DefaultResourceJob::doStart()
 {
     d->tryFetchResource();
 }
 
 void DefaultResourceJob::slotResult(KJob *job)
 {
     if (job->error()) {
         qCWarning(AKONADICORE_LOG) << job->errorText();
         // Do some cleanup.
         if (!d->mResourceWasPreexisting) {
             // We only removed the resource instance if we have created it.
             // Otherwise we might lose the user's data.
             const AgentInstance resource = AgentManager::self()->instance(defaultResourceId(d->mSettings));
             qCDebug(AKONADICORE_LOG) << "Removing resource" << resource.identifier();
             AgentManager::self()->removeInstance(resource);
         }
     }
 
     Job::slotResult(job);
 }
 
 // ===================== GetLockJob ============================
 
 class Akonadi::GetLockJobPrivate
 {
 public:
     explicit GetLockJobPrivate(GetLockJob *qq);
 
     void doStart(); // slot
     void timeout(); // slot
 
     GetLockJob *const q;
     QTimer *mSafetyTimer = nullptr;
 };
 
 GetLockJobPrivate::GetLockJobPrivate(GetLockJob *qq)
     : q(qq)
     , mSafetyTimer(nullptr)
 {
 }
 
 void GetLockJobPrivate::doStart()
 {
     // Just doing registerService() and checking its return value is not sufficient,
     // since we may *already* own the name, and then registerService() returns true.
 
     QDBusConnection bus = QDBusConnection::sessionBus();
     const bool alreadyLocked = bus.interface()->isServiceRegistered(dbusServiceName());
     const bool gotIt = bus.registerService(dbusServiceName());
 
     if (gotIt && !alreadyLocked) {
         // qCDebug(AKONADICORE_LOG) << "Got lock immediately.";
         q->emitResult();
     } else {
         auto watcher = new QDBusServiceWatcher(dbusServiceName(), QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForUnregistration, q);
         QObject::connect(watcher, &QDBusServiceWatcher::serviceUnregistered, q, [this]() {
             if (QDBusConnection::sessionBus().registerService(dbusServiceName())) {
                 mSafetyTimer->stop();
                 q->emitResult();
             }
         });
 
         mSafetyTimer = new QTimer(q);
         mSafetyTimer->setSingleShot(true);
         mSafetyTimer->setInterval(LOCK_WAIT_TIMEOUT_SECONDS * 1000);
         mSafetyTimer->start();
         QObject::connect(mSafetyTimer, &QTimer::timeout, q, [this]() {
             timeout();
         });
     }
 }
 
 void GetLockJobPrivate::timeout()
 {
     qCWarning(AKONADICORE_LOG) << "Timeout trying to get lock. Check who has acquired the name" << dbusServiceName() << "on DBus, using qdbus or qdbusviewer.";
     q->setError(Job::Unknown);
     q->setErrorText(i18n("Timeout trying to get lock."));
     q->emitResult();
 }
 
 GetLockJob::GetLockJob(QObject *parent)
     : KJob(parent)
     , d(new GetLockJobPrivate(this))
 {
 }
 
 GetLockJob::~GetLockJob() = default;
 
 void GetLockJob::start()
 {
     QTimer::singleShot(0, this, [this]() {
         d->doStart();
     });
 }
 
 void Akonadi::setCollectionAttributes(Akonadi::Collection &collection,
                                       const QByteArray &type,
                                       const QMap<QByteArray, QString> &nameForType,
                                       const QMap<QByteArray, QString> &iconForType)
 {
     {
         auto attr = new EntityDisplayAttribute;
         attr->setIconName(iconForType.value(type));
         attr->setDisplayName(nameForType.value(type));
         collection.addAttribute(attr);
     }
 
     {
         auto attr = new SpecialCollectionAttribute;
         attr->setCollectionType(type);
         collection.addAttribute(attr);
     }
 }
 
 bool Akonadi::releaseLock()
 {
     return QDBusConnection::sessionBus().unregisterService(dbusServiceName());
 }
 
 #include "moc_specialcollectionshelperjobs_p.cpp"