diff options
Diffstat (limited to 'src/libs/installer/packagemanagercore.cpp')
| -rw-r--r-- | src/libs/installer/packagemanagercore.cpp | 1763 |
1 files changed, 1313 insertions, 450 deletions
diff --git a/src/libs/installer/packagemanagercore.cpp b/src/libs/installer/packagemanagercore.cpp index addb291eb..5c6f481f9 100644 --- a/src/libs/installer/packagemanagercore.cpp +++ b/src/libs/installer/packagemanagercore.cpp @@ -1,6 +1,6 @@ /************************************************************************** ** -** Copyright (C) 2021 The Qt Company Ltd. +** Copyright (C) 2024 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the Qt Installer Framework. @@ -31,6 +31,7 @@ #include "adminauthorization.h" #include "binarycontent.h" #include "component.h" +#include "componentalias.h" #include "componentmodel.h" #include "downloadarchivesjob.h" #include "errors.h" @@ -46,6 +47,7 @@ #include "installercalculator.h" #include "uninstallercalculator.h" #include "loggingutils.h" +#include "componentsortfilterproxymodel.h" #include <productkeycheck.h> @@ -54,12 +56,17 @@ #include <QtConcurrentRun> #include <QtCore/QMutex> -#include <QtCore/QRegExp> #include <QtCore/QSettings> #include <QtCore/QTemporaryFile> +#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) +#include <QtCore5Compat/QTextCodec> +#include <QtCore5Compat/QTextDecoder> +#include <QtCore5Compat/QTextEncoder> +#else #include <QtCore/QTextCodec> #include <QtCore/QTextDecoder> #include <QtCore/QTextEncoder> +#endif #include <QtCore/QTextStream> #include <QDesktopServices> @@ -176,25 +183,6 @@ using namespace QInstaller; Emitted when the new root component \a comp is added. \sa {installer::componentAdded}{installer.componentAdded} - \sa rootComponentsAdded(), updaterComponentsAdded() -*/ - -/*! - \fn QInstaller::PackageManagerCore::rootComponentsAdded(QList<QInstaller::Component*> components) - - Emitted when the list of root components specified by \a components is added. - - \sa {installer::rootComponentsAdded}{installer.rootComponentsAdded} - \sa componentAdded(), updaterComponentsAdded() -*/ - -/*! - \fn QInstaller::PackageManagerCore::updaterComponentsAdded(QList<QInstaller::Component*> components) - - Emitted when a new list of updater components specified by \a components is added. - - \sa {installer::updaterComponentsAdded}{installer.updaterComponentsAdded} - \sa componentAdded(), rootComponentsAdded() */ /*! @@ -214,6 +202,13 @@ using namespace QInstaller; */ /*! + \fn QInstaller::PackageManagerCore::defaultTranslationsLoadedForLanguage(QLocale lang) + + Emitted when the language \a lang has changed. + +*/ + +/*! \fn QInstaller::PackageManagerCore::finishButtonClicked() \sa {installer::finishButtonClicked}{installer.finishButtonClicked} @@ -339,6 +334,14 @@ using namespace QInstaller; */ /*! + \fn QInstaller::PackageManagerCore::downloadArchivesFinished() + + Emitted when all data archives for components have been downloaded successfully. + + \sa {installer::downloadArchivesFinished}{installer.downloadArchivesFinished} +*/ + +/*! \fn QInstaller::PackageManagerCore::wizardPageInsertionRequested(QWidget *widget, QInstaller::PackageManagerCore::WizardPage page) Emitted when a custom \a widget is about to be inserted into \a page by @@ -444,6 +447,7 @@ static bool sNoForceInstallation = false; static bool sNoDefaultInstallation = false; static bool sVirtualComponentsVisible = false; static bool sCreateLocalRepositoryFromBinary = false; +static int sMaxConcurrentOperations = 0; static bool componentMatches(const Component *component, const QString &name, const QString &version = QString()) @@ -516,7 +520,6 @@ void PackageManagerCore::reset() d->m_status = PackageManagerCore::Unfinished; d->m_installerBaseBinaryUnreplaced.clear(); d->m_coreCheckedHash.clear(); - d->m_componentsToInstallCalculated = false; } /*! @@ -558,50 +561,113 @@ void PackageManagerCore::cancelMetaInfoJob() } /*! - \sa {installer::componentsToInstallNeedsRecalculation}{installer.componentsToInstallNeedsRecalculation} - */ -void PackageManagerCore::componentsToInstallNeedsRecalculation() + Resets the cache used to store downloaded metadata, if one was previously + initialized. If \a init is set to \c true, the cache is reinitialized for + the path configured in installer's settings. + + Returns \c true on success, \c false otherwise. +*/ +bool PackageManagerCore::resetLocalCache(bool init) { - d->clearInstallerCalculator(); - d->clearUninstallerCalculator(); - QList<Component*> selectedComponentsToInstall = componentsMarkedForInstallation(); + return d->m_metadataJob.resetCache(init); +} - d->m_componentsToInstallCalculated = - d->installerCalculator()->appendComponentsToInstall(selectedComponentsToInstall); +/*! + Clears the contents of the cache used to store downloaded metadata. + Returns \c true on success, \c false otherwise. An error string can + be retrieved with \a error. +*/ +bool PackageManagerCore::clearLocalCache(QString *error) +{ + if (d->m_metadataJob.clearCache()) + return true; - QList<Component *> componentsToInstall = d->installerCalculator()->orderedComponentsToInstall(); + if (error) + *error = d->m_metadataJob.errorString(); - QList<Component *> selectedComponentsToUninstall; - foreach (Component *component, components(ComponentType::All)) { - if (component->uninstallationRequested() && !selectedComponentsToInstall.contains(component)) - selectedComponentsToUninstall.append(component); - } + return false; +} - d->uninstallerCalculator()->appendComponentsToUninstall(selectedComponentsToUninstall); +/*! + Returns \c true if the metadata cache is initialized and valid, \c false otherwise. +*/ +bool PackageManagerCore::isValidCache() const +{ + return d->m_metadataJob.isValidCache(); +} - QSet<Component *> componentsToUninstall = d->uninstallerCalculator()->componentsToUninstall(); +/*! + \internal + */ +template <typename T> +bool PackageManagerCore::loadComponentScripts(const T &components, const bool postScript) +{ + return d->loadComponentScripts(components, postScript); +} - foreach (Component *component, components(ComponentType::All)) - component->setInstallAction(component->isInstalled() - ? ComponentModelHelper::KeepInstalled - : ComponentModelHelper::KeepUninstalled); - foreach (Component *component, componentsToUninstall) - component->setInstallAction(ComponentModelHelper::Uninstall); - foreach (Component *component, componentsToInstall) - component->setInstallAction(ComponentModelHelper::Install); +template bool PackageManagerCore::loadComponentScripts<QList<Component *>>(const QList<Component *> &, const bool); +template bool PackageManagerCore::loadComponentScripts<QHash<QString, Component *>>(const QHash<QString, Component *> &, const bool); - // update all nodes uncompressed size - foreach (Component *const component, components(ComponentType::Root)) - component->updateUncompressedSize(); // this is a recursive call +/*! + Saves the installer \a args user has given when running installer. Command and option arguments + are not saved. +*/ +void PackageManagerCore::saveGivenArguments(const QStringList &args) +{ + m_arguments = args; } /*! - Forces a recalculation of components to install. + Returns the commands and options user has given when running installer. +*/ +QStringList PackageManagerCore::givenArguments() const +{ + return m_arguments; +} +/*! + \deprecated [4.5] Use recalculateAllComponents() instead. + + \sa {installer::componentsToInstallNeedsRecalculation}{installer.componentsToInstallNeedsRecalculation} + */ +void PackageManagerCore::componentsToInstallNeedsRecalculation() +{ + recalculateAllComponents(); +} + +/*! + \fn QInstaller::PackageManagerCore::clearComponentsToInstallCalculated() + + \deprecated [4.5] Installer framework recalculates components each time the calculation + of components to install is requested, so there is no need to call this anymore, and the + method does nothing. On previous versions calling this forced a recalculation of + components to install. + \sa {installer::clearComponentsToInstallCalculated}{installer.clearComponentsToInstallCalculated} */ -void PackageManagerCore::clearComponentsToInstallCalculated() + +/*! + Recalculates all components to install and uninstall. Returns \c true + on success, \c false otherwise. Detailed error messages can be retrieved + with {installer::componentsToInstallError} and {installer::componentsToUninstallError}. + */ +bool PackageManagerCore::recalculateAllComponents() { - d->m_componentsToInstallCalculated = false; + // Clear previous results first, as the check states are updated + // at the end of both calculate methods, which refer to the results + // from both calculators. Needed to keep the state correct. + d->clearInstallerCalculator(); + d->clearUninstallerCalculator(); + + if (!calculateComponentsToInstall()) + return false; + if (!isInstaller() && !calculateComponentsToUninstall()) + return false; + + // update all nodes uncompressed size + foreach (Component *const component, components(ComponentType::Root)) + component->updateUncompressedSize(); // this is a recursive call + + return true; } /*! @@ -745,12 +811,13 @@ quint64 PackageManagerCore::requiredDiskSpace() const */ quint64 PackageManagerCore::requiredTemporaryDiskSpace() const { - if (isOfflineOnly()) - return 0; - quint64 result = 0; - foreach (QInstaller::Component *component, orderedComponentsToInstall()) + foreach (QInstaller::Component *component, orderedComponentsToInstall()) { + if (!component->isFromOnlineRepository()) + continue; + result += size(component, scCompressedSize); + } return result; } @@ -763,31 +830,43 @@ int PackageManagerCore::downloadNeededArchives(double partProgressSize) { Q_ASSERT(partProgressSize >= 0 && partProgressSize <= 1); - QList<QPair<QString, QString> > archivesToDownload; + QList<DownloadItem> archivesToDownload; + quint64 archivesToDownloadTotalSize = 0; QList<Component*> neededComponents = orderedComponentsToInstall(); foreach (Component *component, neededComponents) { // collect all archives to be downloaded const QStringList toDownload = component->downloadableArchives(); + bool checkSha1CheckSum = (component->value(scCheckSha1CheckSum).toLower() == scTrue); foreach (const QString &versionFreeString, toDownload) { - archivesToDownload.push_back(qMakePair(QString::fromLatin1("installer://%1/%2") - .arg(component->name(), versionFreeString), QString::fromLatin1("%1/%2/%3") - .arg(component->repositoryUrl().toString(), component->name(), versionFreeString))); + DownloadItem item; + item.checkSha1CheckSum = checkSha1CheckSum; + item.fileName = scInstallerPrefixWithTwoArgs.arg(component->name(), versionFreeString); + item.sourceUrl = scThreeArgs.arg(component->repositoryUrl().toString(), component->name(), versionFreeString); + archivesToDownload.push_back(item); } + archivesToDownloadTotalSize += component->value(scCompressedSize).toULongLong(); } if (archivesToDownload.isEmpty()) return 0; - ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("\nDownloading packages...")); + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Downloading packages...")); - DownloadArchivesJob archivesJob(this); + DownloadArchivesJob archivesJob(this, QLatin1String("downloadArchiveJob")); archivesJob.setAutoDelete(false); archivesJob.setArchivesToDownload(archivesToDownload); + archivesJob.setExpectedTotalSize(archivesToDownloadTotalSize); connect(this, &PackageManagerCore::installationInterrupted, &archivesJob, &Job::cancel); connect(&archivesJob, &DownloadArchivesJob::outputTextChanged, ProgressCoordinator::instance(), &ProgressCoordinator::emitLabelAndDetailTextChanged); connect(&archivesJob, &DownloadArchivesJob::downloadStatusChanged, - ProgressCoordinator::instance(), &ProgressCoordinator::downloadStatusChanged); + ProgressCoordinator::instance(), &ProgressCoordinator::additionalProgressStatusChanged); + + connect(&archivesJob, &DownloadArchivesJob::fileDownloadReady, + d, &PackageManagerCorePrivate::addPathForDeletion); + connect(&archivesJob, &DownloadArchivesJob::hashDownloadReady, + d, &PackageManagerCorePrivate::addPathForDeletion); ProgressCoordinator::instance()->registerPartProgress(&archivesJob, SIGNAL(progressChanged(double)), partProgressSize); @@ -803,7 +882,8 @@ int PackageManagerCore::downloadNeededArchives(double partProgressSize) if (d->statusCanceledOrFailed()) throw Error(tr("Installation canceled by user.")); - ProgressCoordinator::instance()->emitDownloadStatus(tr("All downloads finished.")); + ProgressCoordinator::instance()->emitAdditionalProgressStatus(tr("All downloads finished.")); + emit downloadArchivesFinished(); return archivesJob.numberOfDownloads(); } @@ -926,7 +1006,7 @@ void PackageManagerCore::rollBackInstallation() */ bool PackageManagerCore::isFileExtensionRegistered(const QString &extension) const { - QSettingsWrapper settings(QLatin1String("HKEY_CLASSES_ROOT"), QSettingsWrapper::NativeFormat); + QSettingsWrapper settings(QLatin1String("HKEY_CLASSES_ROOT"), QSettings::NativeFormat); return settings.value(QString::fromLatin1(".%1/Default").arg(extension)).isValid(); } @@ -941,7 +1021,7 @@ bool PackageManagerCore::isFileExtensionRegistered(const QString &extension) con */ bool PackageManagerCore::fileExists(const QString &filePath) const { - return QFileInfo(filePath).exists(); + return QFileInfo::exists(filePath); } /*! @@ -966,8 +1046,7 @@ QString PackageManagerCore::readFile(const QString &filePath, const QString &cod return QString(); QTextStream stream(&f); - stream.setCodec(codec); - return stream.readAll(); + return QString::fromUtf8(codec->fromUnicode(stream.readAll())); } /*! @@ -1000,8 +1079,46 @@ QString PackageManagerCore::readConsoleLine(const QString &title, qint64 maxlen) } /*! - Checks whether the target directory \a targetDirectory exists and has contents: + Returns \a path with the '/' separators converted to separators that are + appropriate for the underlying operating system. + + On Unix platforms the returned string is the same as the argument. + + \note Predefined variables, such as @TargetDir@, are not resolved by + this function. To convert the separators to predefined variables, use + \c installer.value() to resolve the variables first. + + \sa {installer::toNativeSeparators}{installer.toNativeSeparators} + \sa fromNativeSeparators() + \sa {installer::value}{installer.value} +*/ +QString PackageManagerCore::toNativeSeparators(const QString &path) +{ + return QDir::toNativeSeparators(path); +} + +/*! + Returns \a path using '/' as file separator. + + On Unix platforms the returned string is the same as the argument. + + \note Predefined variables, such as @TargetDir@, are not resolved by + this function. To convert the separators to predefined variables, use + \c installer.value() to resolve the variables first. + + \sa {installer::fromNativeSeparators}{installer.fromNativeSeparators} + \sa toNativeSeparators() + \sa {installer::value}{installer.value} +*/ +QString PackageManagerCore::fromNativeSeparators(const QString &path) +{ + return QDir::fromNativeSeparators(path); +} + +/*! + Checks whether installation is allowed to \a targetDirectory: \list + \li Returns \c true if the directory does not exist. \li Returns \c true if the directory exists and is empty. \li Returns \c false if the directory already exists and contains an installation. \li Returns \c false if the target is a file or a symbolic link. @@ -1009,14 +1126,17 @@ QString PackageManagerCore::readConsoleLine(const QString &title, qint64 maxlen) choice that the end users make in the displayed message box. \endlist */ -bool PackageManagerCore::checkTargetDir(const QString &targetDirectory) +bool PackageManagerCore::installationAllowedToDirectory(const QString &targetDirectory) { + const QFileInfo fi(targetDirectory); + if (!fi.exists()) + return true; + const QDir dir(targetDirectory); // the directory exists and is empty... if (dir.exists() && dir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot).isEmpty()) return true; - const QFileInfo fi(targetDirectory); if (fi.isDir()) { QString fileName = settings().maintenanceToolName(); #if defined(Q_OS_MACOS) @@ -1073,8 +1193,8 @@ QString PackageManagerCore::targetDirWarning(const QString &targetDirectory) con } } - target = target.canonicalPath(); - if (!target.isEmpty() && (target == QDir::root() || target == QDir::home())) { + target.setPath(target.canonicalPath()); + if (!target.path().isEmpty() && (target == QDir::root() || target == QDir::home())) { return tr("As the install directory is completely deleted, installing in %1 is forbidden.") .arg(QDir::toNativeSeparators(target.path())); } @@ -1167,11 +1287,16 @@ PackageManagerCore::PackageManagerCore() Creates and initializes a remote client. Requests administrator's rights for QFile, QSettings, and QProcess operations. Calls \c init() with \a socketName, \a key, and \a mode to set the server side authorization key. + + The \a datFileName contains the corresponding .dat file name for the running + \c maintenance tool binary. \a datFileName can be empty if \c maintenance tool + fails to find it or if \c installer is run instead of \c maintenance tool. */ PackageManagerCore::PackageManagerCore(qint64 magicmaker, const QList<OperationBlob> &operations, + const QString &datFileName, const QString &socketName, const QString &key, Protocol::Mode mode, const QHash<QString, QString> ¶ms, const bool commandLineInstance) - : d(new PackageManagerCorePrivate(this, magicmaker, operations)) + : d(new PackageManagerCorePrivate(this, magicmaker, operations, datFileName)) { setCommandLineInstance(commandLineInstance); Repository::registerMetaType(); // register, cause we stream the type as QVariant @@ -1191,7 +1316,8 @@ PackageManagerCore::PackageManagerCore(qint64 magicmaker, const QList<OperationB // Sanity check to detect a broken installations with missing operations. // Every installed package should have at least one MinimalProgress operation. // - QSet<QString> installedPackages = d->m_core->localInstalledPackages().keys().toSet(); + const QStringList localPackageList = d->m_core->localInstalledPackages().keys(); + QSet<QString> installedPackages(localPackageList.begin(), localPackageList.end()); QSet<QString> operationPackages; foreach (QInstaller::Operation *operation, d->m_performedOperationsOld) { if (operation->hasValue(QLatin1String("component"))) @@ -1201,8 +1327,8 @@ PackageManagerCore::PackageManagerCore(qint64 magicmaker, const QList<OperationB QSet<QString> packagesWithoutOperation = installedPackages - operationPackages; QSet<QString> orphanedOperations = operationPackages - installedPackages; if (!packagesWithoutOperation.isEmpty() || !orphanedOperations.isEmpty()) { - qCritical() << "Operations missing for installed packages" << packagesWithoutOperation.toList(); - qCritical() << "Orphaned operations" << orphanedOperations.toList(); + qCritical() << "Operations missing for installed packages" << packagesWithoutOperation.values(); + qCritical() << "Orphaned operations" << orphanedOperations.values(); qCritical() << "Your installation seems to be corrupted. Please consider re-installing from scratch, " "remove the packages from components.xml which operations are missing, " "or reinstall the packages."; @@ -1350,6 +1476,30 @@ void PackageManagerCore::setCreateLocalRepositoryFromBinary(bool create) sCreateLocalRepositoryFromBinary = create; } +/* static */ +/*! + Returns the maximum count of operations that should be run concurrently + at the given time. + + Currently this affects only operations in the unpacking phase. +*/ +int PackageManagerCore::maxConcurrentOperations() +{ + return sMaxConcurrentOperations; +} + +/* static */ +/*! + Sets the maximum \a count of operations that should be run concurrently + at the given time. A value of \c 0 is synonym for automatic count. + + Currently this affects only operations in the unpacking phase. +*/ +void PackageManagerCore::setMaxConcurrentOperations(int count) +{ + sMaxConcurrentOperations = count; +} + /*! Returns \c true if the package manager is running and installed packages are found. Otherwise, returns \c false. @@ -1363,7 +1513,7 @@ bool PackageManagerCore::fetchLocalPackagesTree() return false; } - LocalPackagesHash installedPackages = d->localInstalledPackages(); + LocalPackagesMap installedPackages = d->localInstalledPackages(); if (installedPackages.isEmpty()) { if (status() != Failure) d->setStatus(Failure, tr("No installed packages found.")); @@ -1374,23 +1524,64 @@ bool PackageManagerCore::fetchLocalPackagesTree() d->clearAllComponentLists(); QHash<QString, QInstaller::Component*> components; + QMap<QString, QString> treeNameComponents; - const QStringList &keys = installedPackages.keys(); - foreach (const QString &key, keys) { - QScopedPointer<QInstaller::Component> component(new QInstaller::Component(this)); - component->loadDataFromPackage(installedPackages.value(key)); - const QString &name = component->treeName(); - if (components.contains(name)) { - d->setStatus(Failure, tr("Cannot register component! Component with identifier %1 " - "already exists.").arg(name)); - return false; + std::function<void(QList<LocalPackage> *, bool)> loadLocalPackages; + loadLocalPackages = [&](QList<LocalPackage> *treeNamePackages, bool firstRun) { + foreach (auto &package, (firstRun ? installedPackages.values() : *treeNamePackages)) { + if (firstRun && !package.treeName.first.isEmpty()) { + // Package has a tree name, leave for later + treeNamePackages->append(package); + continue; + } + + std::unique_ptr<QInstaller::Component> component(new QInstaller::Component(this)); + component->loadDataFromPackage(package); + QString name = component->treeName(); + if (components.contains(name)) { + qCritical() << "Cannot register component" << component->name() << "with name" << name + << "! Component with identifier" << name << "already exists."; + // Conflicting original name, skip. + if (component->value(scTreeName).isEmpty()) + continue; + + // Conflicting tree name, check if we can add with original name. + name = component->name(); + if (!settings().allowUnstableComponents() || components.contains(name)) + continue; + + qCDebug(lcInstallerInstallLog) + << "Registering component with the original indetifier:" << name; + component->removeValue(scTreeName); + const QString errorString = QLatin1String("Tree name conflicts with an existing indentifier"); + d->m_pendingUnstableComponents.insert(component->name(), + QPair<Component::UnstableError, QString>(Component::InvalidTreeName, errorString)); + } + const QString treeName = component->value(scTreeName); + if (!treeName.isEmpty()) + treeNameComponents.insert(component->name(), treeName); + + components.insert(name, component.release()); } - components.insert(name, component.take()); + // Second pass with leftover packages + if (firstRun) + loadLocalPackages(treeNamePackages, false); + }; + + { + // Loading package data is performed in two steps: first, components without + // - and then components with tree names. This is to ensure components with tree + // names do not replace other components when registering fails to a name conflict. + QList<LocalPackage> treeNamePackagesTmp; + loadLocalPackages(&treeNamePackagesTmp, true); } + createAutoTreeNames(components, treeNameComponents); + if (!d->buildComponentTree(components, false)) return false; + d->commitPendingUnstableComponents(); updateDisplayVersions(scDisplayVersion); emit finishAllComponentsReset(d->m_rootComponents); @@ -1402,7 +1593,7 @@ bool PackageManagerCore::fetchLocalPackagesTree() /*! Returns a list of local installed packages. The list can be empty. */ -LocalPackagesHash PackageManagerCore::localInstalledPackages() +LocalPackagesMap PackageManagerCore::localInstalledPackages() { return d->localInstalledPackages(); } @@ -1415,10 +1606,11 @@ void PackageManagerCore::networkSettingsChanged() cancelMetaInfoJob(); d->m_updates = false; + d->m_aliases = false; d->m_repoFetched = false; d->m_updateSourcesAdded = false; - if (isMaintainer() ) { + if (!isInstaller()) { bool gainedAdminRights = false; if (!directoryWritable(d->targetDir())) { gainAdminRights(); @@ -1473,33 +1665,60 @@ PackagesList PackageManagerCore::remotePackages() */ bool PackageManagerCore::fetchCompressedPackagesTree() { - const LocalPackagesHash installedPackages = d->localInstalledPackages(); + const LocalPackagesMap installedPackages = d->localInstalledPackages(); if (!isInstaller() && status() == Failure) return false; - if (!d->fetchMetaInformationFromCompressedRepositories()) + if (!d->fetchMetaInformationFromRepositories(DownloadType::CompressedPackage)) return false; - if (!d->addUpdateResourcesFromRepositories(true, true)) { + if (!d->addUpdateResourcesFromRepositories(true)) { return false; } - PackagesList packages; - const PackagesList &compPackages = d->compressedPackages(); - if (compPackages.isEmpty()) + const PackagesList &packages = d->remotePackages(); + if (packages.isEmpty()) return false; - packages.append(compPackages); - const PackagesList &rPackages = d->remotePackages(); - packages.append(rPackages); return fetchPackagesTree(packages, installedPackages); } +bool PackageManagerCore::fetchPackagesWithFallbackRepositories(const QStringList& components, bool &fallBackReposFetched) +{ + auto checkComponents = [&]() { + if (!fetchRemotePackagesTree(components)) + return false; + return true; + }; + + if (!checkComponents()) { + // error when fetching packages tree + if (status() != NoPackagesFound) + return false; + //retry fetching packages with all categories enabled + fallBackReposFetched = true; + if (!d->enableAllCategories()) + return false; + + qCDebug(QInstaller::lcInstallerInstallLog).noquote() + << "Components not found with the current selection." + << "Searching from additional repositories"; + if (!ProductKeyCheck::instance()->securityWarning().isEmpty()) { + qCWarning(QInstaller::lcInstallerInstallLog) << ProductKeyCheck::instance()->securityWarning(); + } + if (!checkComponents()) { + return false; + } + } + return true; +} + /*! Checks for packages to install. Returns \c true if newer versions exist - and they can be installed. + and they can be installed. Returns \c false if not \a components are found + for install, or if error occurred when fetching and generating package tree. */ -bool PackageManagerCore::fetchRemotePackagesTree() +bool PackageManagerCore::fetchRemotePackagesTree(const QStringList& components) { d->setStatus(Running); @@ -1513,27 +1732,32 @@ bool PackageManagerCore::fetchRemotePackagesTree() return false; } - const LocalPackagesHash installedPackages = d->localInstalledPackages(); + const LocalPackagesMap installedPackages = d->localInstalledPackages(); if (!isInstaller() && status() == Failure) return false; if (!d->fetchMetaInformationFromRepositories()) return false; - if (!d->fetchMetaInformationFromCompressedRepositories()) + if (!d->fetchMetaInformationFromRepositories(DownloadType::CompressedPackage)) return false; - if (!d->addUpdateResourcesFromRepositories(true)) + if (!d->addUpdateResourcesFromRepositories()) return false; const PackagesList &packages = d->remotePackages(); - if (packages.isEmpty()) + if (packages.isEmpty()) { + d->setStatus(PackageManagerCore::NoPackagesFound); + return false; + } + + if (!d->installablePackagesFound(components)) return false; return fetchPackagesTree(packages, installedPackages); } -bool PackageManagerCore::fetchPackagesTree(const PackagesList &packages, const LocalPackagesHash installedPackages) { +bool PackageManagerCore::fetchPackagesTree(const PackagesList &packages, const LocalPackagesMap installedPackages) { bool success = false; if (!isUpdater()) { @@ -1778,24 +2002,82 @@ void PackageManagerCore::setTemporaryRepositories(const QStringList &repositorie settings().setTemporaryRepositories(repositorySet, replace); } -/*! - Checks whether the downloader should try to download SHA-1 checksums for - archives and returns the checksums. -*/ -bool PackageManagerCore::testChecksum() const +bool PackageManagerCore::addQBspRepositories(const QStringList &repositories) { - return d->m_testChecksum; + QSet<Repository> set; + foreach (QString fileName, repositories) { + Repository repository = Repository::fromUserInput(fileName, true); + repository.setEnabled(true); + set.insert(repository); + } + if (set.count() > 0) { + settings().addTemporaryRepositories(set, false); + return true; + } + return false; } -/*! - The \a test argument determines whether the downloader should try to - download SHA-1 checksums for archives. -*/ -void PackageManagerCore::setTestChecksum(bool test) +bool PackageManagerCore::validRepositoriesAvailable() const +{ + foreach (const Repository &repo, settings().repositories()) { + if (repo.isEnabled() && repo.isValid()) { + return true; + } + } + return false; +} + +void PackageManagerCore::setAllowCompressedRepositoryInstall(bool allow) { - d->m_testChecksum = test; + d->m_allowCompressedRepositoryInstall = allow; } +bool PackageManagerCore::allowCompressedRepositoryInstall() const +{ + return d->m_allowCompressedRepositoryInstall; +} + +bool PackageManagerCore::showRepositoryCategories() const +{ + bool showCagetories = settings().repositoryCategories().count() > 0 && !isOfflineOnly() && !isUpdater(); + if (showCagetories) + settings().setAllowUnstableComponents(true); + return showCagetories; +} + +QVariantMap PackageManagerCore::organizedRepositoryCategories() const +{ + QVariantMap map; + QSet<RepositoryCategory> categories = settings().repositoryCategories(); + foreach (const RepositoryCategory &category, categories) + map.insert(category.displayname(), QVariant::fromValue(category)); + return map; +} + +void PackageManagerCore::enableRepositoryCategory(const QString &repositoryName, bool enable) +{ + QMap<QString, RepositoryCategory> organizedRepositoryCategories = settings().organizedRepositoryCategories(); + + QMap<QString, RepositoryCategory>::iterator i = organizedRepositoryCategories.find(repositoryName); + while (i != organizedRepositoryCategories.end() && i.key() == repositoryName) { + d->enableRepositoryCategory(i.value(), enable); + i++; + } +} + +void PackageManagerCore::runProgram() +{ + const QString program = replaceVariables(value(scRunProgram)); + + const QStringList args = replaceVariables(values(scRunProgramArguments)); + if (program.isEmpty()) + return; + + qCDebug(QInstaller::lcInstallerInstallLog) << "starting" << program << args; + QProcess::startDetached(program, args); +} + + /*! Returns the script engine that prepares and runs the component scripts. @@ -1824,6 +2106,10 @@ ScriptEngine *PackageManagerCore::controlScriptEngine() const */ void PackageManagerCore::appendRootComponent(Component *component) { + // For normal installer runs components aren't appended after model reset + if (Q_UNLIKELY(!d->m_componentByNameHash.isEmpty())) + d->m_componentByNameHash.clear(); + d->m_rootComponents.append(component); emit componentAdded(component); } @@ -1889,7 +2175,7 @@ QList<Component *> PackageManagerCore::components(ComponentTypes mask, const QSt QRegularExpression re(regexp); QList<Component*>::iterator iter = components.begin(); while (iter != components.end()) { - if (!re.match(iter.i->t()->name()).hasMatch()) + if (!re.match((*iter)->name()).hasMatch()) iter = components.erase(iter); else iter++; @@ -1905,6 +2191,10 @@ QList<Component *> PackageManagerCore::components(ComponentTypes mask, const QSt */ void PackageManagerCore::appendUpdaterComponent(Component *component) { + // For normal installer runs components aren't appended after model reset + if (Q_UNLIKELY(!d->m_componentByNameHash.isEmpty())) + d->m_componentByNameHash.clear(); + component->setUpdateAvailable(true); d->m_updaterComponents.append(component); emit componentAdded(component); @@ -1918,7 +2208,39 @@ void PackageManagerCore::appendUpdaterComponent(Component *component) */ Component *PackageManagerCore::componentByName(const QString &name) const { - return componentByName(name, components(ComponentType::AllNoReplacements)); + if (name.isEmpty()) + return nullptr; + + if (d->m_componentByNameHash.isEmpty()) { + // We can avoid the linear lookups from the component list by creating + // a <name,component> hash once, and reusing it on subsequent calls. + const QList<Component *> componentsList = components(ComponentType::AllNoReplacements); + for (Component *component : componentsList) + d->m_componentByNameHash.insert(component->name(), component); + } + + QString fixedVersion; + QString fixedName; + + parseNameAndVersion(name, &fixedName, &fixedVersion); + + Component *component = d->m_componentByNameHash.value(fixedName); + if (!component) + return nullptr; + + if (componentMatches(component, fixedName, fixedVersion)) + return component; + + return nullptr; +} + +/*! + Searches for a component alias matching \a name and returns it. + If no alias matches the name, \c nullptr is returned. +*/ +ComponentAlias *PackageManagerCore::aliasByName(const QString &name) const +{ + return d->m_componentAliases.value(name); } /*! @@ -1947,6 +2269,18 @@ Component *PackageManagerCore::componentByName(const QString &name, const QList< } /*! + Returns an array of all components currently available. If the repository + metadata have not been fetched yet, the array will be empty. Optionally, a + \a regexp expression can be used to further filter the listed packages. + + \sa {installer::components}{installer.components} + */ +QList<Component *> PackageManagerCore::components(const QString ®exp) const +{ + return components(PackageManagerCore::ComponentType::All, regexp); +} + +/*! Returns \c true if directory specified by \a path is writable by the current user. */ @@ -1984,8 +2318,27 @@ QList<Component *> PackageManagerCore::componentsMarkedForInstallation() const } /*! - Determines which components to install based on the current run mode and returns an - ordered list of components to install. Also auto installed dependencies are resolved. + Returns a list of component aliases that are marked for installation. + The list can be empty. +*/ +QList<ComponentAlias *> PackageManagerCore::aliasesMarkedForInstallation() const +{ + if (isUpdater()) // Aliases not supported on update at the moment + return QList<ComponentAlias *>(); + + QList<ComponentAlias *> markedForInstallation; + for (auto *alias : qAsConst(d->m_componentAliases)) { + if (alias && alias->isSelected()) + markedForInstallation.append(alias); + } + + return markedForInstallation; +} + +/*! + Determines which components to install based on the current run mode, including component aliases, + dependencies and automatic dependencies. Returns \c true on success, \c false otherwise. + The aboutCalculateComponentsToInstall() signal is emitted before the calculation starts, the finishedCalculateComponentsToInstall() signal once all calculations are done. @@ -1996,16 +2349,15 @@ QList<Component *> PackageManagerCore::componentsMarkedForInstallation() const bool PackageManagerCore::calculateComponentsToInstall() const { emit aboutCalculateComponentsToInstall(); - if (!d->m_componentsToInstallCalculated) { - d->clearInstallerCalculator(); - QList<Component*> selectedComponentsToInstall = componentsMarkedForInstallation(); - d->storeCheckState(); - d->m_componentsToInstallCalculated = - d->installerCalculator()->appendComponentsToInstall(selectedComponentsToInstall); - } + d->clearInstallerCalculator(); + + const bool calculated = d->installerCalculator()->solve(); + + d->updateComponentInstallActions(); + emit finishedCalculateComponentsToInstall(); - return d->m_componentsToInstallCalculated; + return calculated; } /*! @@ -2013,45 +2365,56 @@ bool PackageManagerCore::calculateComponentsToInstall() const */ QList<Component*> PackageManagerCore::orderedComponentsToInstall() const { - return d->installerCalculator()->orderedComponentsToInstall(); + return d->installerCalculator()->resolvedComponents(); } /*! - Calculates components to install and uninstall. In case of an error, returns \c false - and and sets the \a displayString for error detail. + Returns a HTML-formatted description of the reasons each component is about + to be installed or uninstalled, or a description of the error occurred while + calculating components to install and uninstall. */ - -bool PackageManagerCore::calculateComponents(QString *displayString) +QString PackageManagerCore::componentResolveReasons() const { QString htmlOutput; - QString lastInstallReason; - if (!calculateComponentsToUninstall() || - !calculateComponentsToInstall()) { + if (!componentsToInstallError().isEmpty()) { htmlOutput.append(QString::fromLatin1("<h2><font color=\"red\">%1</font></h2><ul>") - .arg(tr("Cannot resolve all dependencies."))); + .arg(tr("Cannot resolve all dependencies."))); //if we have a missing dependency or a recursion we can display it - if (!componentsToInstallError().isEmpty()) { - htmlOutput.append(QString::fromLatin1("<li> %1 </li>").arg( - componentsToInstallError())); - } + htmlOutput.append(QString::fromLatin1("<li> %1 </li>").arg( + componentsToInstallError())); htmlOutput.append(QLatin1String("</ul>")); - if (displayString) - *displayString = htmlOutput; - return false; + return htmlOutput; } - // In case of updater mode we don't uninstall components. - if (!isUpdater()) { - QList<Component*> componentsToRemove = componentsToUninstall(); - if (!componentsToRemove.isEmpty()) { - htmlOutput.append(QString::fromLatin1("<h3>%1</h3><ul>").arg(tr("Components about to " - "be removed."))); - foreach (Component *component, componentsToRemove) - htmlOutput.append(QString::fromLatin1("<li> %1 </li>").arg(component->name())); + if (!componentsToUninstallError().isEmpty()) { + htmlOutput.append(QString::fromLatin1("<h2><font color=\"red\">%1</font></h2><ul>") + .arg(tr("Cannot resolve components to uninstall."))); + htmlOutput.append(QString::fromLatin1("<li> %1 </li>").arg( + componentsToUninstallError())); + htmlOutput.append(QLatin1String("</ul>")); + return htmlOutput; + } + + QList<Component*> componentsToRemove = componentsToUninstall(); + if (!componentsToRemove.isEmpty()) { + QMap<QString, QStringList> orderedUninstallReasons; + htmlOutput.append(QString::fromLatin1("<h3>%1</h3><ul>").arg(tr("Components about to " + "be removed:"))); + foreach (Component *component, componentsToRemove) { + const QString reason = uninstallReason(component); + QStringList value = orderedUninstallReasons.value(reason); + orderedUninstallReasons.insert(reason, value << component->name()); + } + for (auto &reason : orderedUninstallReasons.keys()) { + htmlOutput.append(QString::fromLatin1("<h4>%1</h4><ul>").arg(reason)); + foreach (const QString componentName, orderedUninstallReasons.value(reason)) + htmlOutput.append(QString::fromLatin1("<li> %1 </li>").arg(componentName)); htmlOutput.append(QLatin1String("</ul>")); } + htmlOutput.append(QLatin1String("</ul>")); } + QString lastInstallReason; foreach (Component *component, orderedComponentsToInstall()) { const QString reason = installReason(component); if (lastInstallReason != reason) { @@ -2062,38 +2425,46 @@ bool PackageManagerCore::calculateComponents(QString *displayString) } htmlOutput.append(QString::fromLatin1("<li> %1 </li>").arg(component->name())); } - if (displayString) - *displayString = htmlOutput; - return true; + return htmlOutput; } /*! - Calculates a list of components to uninstall based on the current run mode. + Calculates a list of components to uninstall. + The aboutCalculateComponentsToUninstall() signal is emitted before the calculation starts, the finishedCalculateComponentsToUninstall() signal once all - calculations are done. Always returns \c true. + calculations are done. Returns \c true on success, \c false otherwise. \sa {installer::calculateComponentsToUninstall}{installer.calculateComponentsToUninstall} */ bool PackageManagerCore::calculateComponentsToUninstall() const { emit aboutCalculateComponentsToUninstall(); - if (!isUpdater()) { - // hack to avoid removing needed dependencies - QSet<Component*> componentsToInstall = d->installerCalculator()->orderedComponentsToInstall().toSet(); - QList<Component*> componentsToUninstall; - foreach (Component *component, components(ComponentType::All)) { - if (component->uninstallationRequested() && !componentsToInstall.contains(component)) - componentsToUninstall.append(component); - } + d->clearUninstallerCalculator(); + const QList<Component *> componentsToInstallList = d->installerCalculator()->resolvedComponents(); - d->clearUninstallerCalculator(); - d->storeCheckState(); - d->uninstallerCalculator()->appendComponentsToUninstall(componentsToUninstall); + QList<Component *> selectedComponentsToUninstall; + foreach (Component* component, components(PackageManagerCore::ComponentType::Replacements)) { + // Uninstall the component if replacement is selected for install or update + QPair<Component*, Component*> comp = d->componentsToReplace().value(component->name()); + if (comp.first && d->m_installerCalculator->resolvedComponents().contains(comp.first)) { + d->uninstallerCalculator()->insertResolution(component, + CalculatorBase::Resolution::Replaced, comp.first->name()); + selectedComponentsToUninstall.append(comp.second); + } + } + foreach (Component *component, components(PackageManagerCore::ComponentType::AllNoReplacements)) { + if (component->uninstallationRequested() && !componentsToInstallList.contains(component)) + selectedComponentsToUninstall.append(component); } + const bool componentsToUninstallCalculated = + d->uninstallerCalculator()->solve(selectedComponentsToUninstall); + + d->updateComponentInstallActions(); + emit finishedCalculateComponentsToUninstall(); - return true; + return componentsToUninstallCalculated; } /*! @@ -2105,7 +2476,7 @@ bool PackageManagerCore::calculateComponentsToUninstall() const */ QList<Component *> PackageManagerCore::componentsToUninstall() const { - return d->uninstallerCalculator()->componentsToUninstall().toList(); + return d->uninstallerCalculator()->resolvedComponents(); } /*! @@ -2113,7 +2484,15 @@ QList<Component *> PackageManagerCore::componentsToUninstall() const */ QString PackageManagerCore::componentsToInstallError() const { - return d->installerCalculator()->componentsToInstallError(); + return d->installerCalculator()->error(); +} + +/*! + Returns errors found in the components that are marked for uninstallation. +*/ +QString PackageManagerCore::componentsToUninstallError() const +{ + return d->uninstallerCalculator()->error(); } /*! @@ -2127,7 +2506,23 @@ QString PackageManagerCore::componentsToInstallError() const */ QString PackageManagerCore::installReason(Component *component) const { - return d->installerCalculator()->installReason(component); + return d->installerCalculator()->resolutionText(component); +} + +/*! + Returns the reason why \a component needs to be uninstalled: + + \list + \li The component was scheduled for uninstallation. + \li The component was replaced by another component. + \li The component is virtual and its dependencies are uninstalled. + \li The components dependencies are uninstalled. + \li The components autodependencies are uninstalled. + \endlist +*/ +QString PackageManagerCore::uninstallReason(Component *component) const +{ + return d->uninstallerCalculator()->resolutionText(component); } /*! @@ -2160,6 +2555,68 @@ QList<Component*> PackageManagerCore::dependees(const Component *_component) con } /*! + Returns true if components which are about to be installed or updated + are dependent on \a component. +*/ +bool PackageManagerCore::isDependencyForRequestedComponent(const Component *component) const +{ + if (!component) + return false; + + const QList<QInstaller::Component *> availableComponents = components(ComponentType::All); + if (availableComponents.isEmpty()) + return false; + + QString name; + QString version; + for (Component *availableComponent : availableComponents) { + if (!availableComponent) { + continue; + } + // 1. In updater mode, component to be updated might have new dependencies + // Check if the dependency is still needed + // 2. If component is selected and not installed, check if the dependency is needed + if (availableComponent->isSelected() + && ((isUpdater() && availableComponent->isInstalled()) + || (isPackageManager() && !availableComponent->isInstalled()))) { + const QStringList &dependencies = availableComponent->dependencies(); + foreach (const QString &dependency, dependencies) { + parseNameAndVersion(dependency, &name, &version); + if (componentMatches(component, name, version)) { + return true; + } + } + } + } + return false; +} + + +/*! + Returns a list of local components which are dependent on \a component. +*/ +QStringList PackageManagerCore::localDependenciesToComponent(const Component *component) const +{ + if (!component) + return QStringList(); + + QStringList dependents; + QString name; + QString version; + + QMap<QString, LocalPackage> localPackages = d->m_localPackageHub->localPackages(); + for (const KDUpdater::LocalPackage &localPackage : qAsConst(localPackages)) { + for (const QString &dependency : localPackage.dependencies) { + parseNameAndVersion(dependency, &name, &version); + if (componentMatches(component, name, version)) { + dependents.append(localPackage.name); + } + } + } + return dependents; +} + +/*! Returns the default component model. */ ComponentModel *PackageManagerCore::defaultComponentModel() const @@ -2168,9 +2625,13 @@ ComponentModel *PackageManagerCore::defaultComponentModel() const if (!d->m_defaultModel) { d->m_defaultModel = componentModel(const_cast<PackageManagerCore*> (this), QLatin1String("AllComponentsModel")); + + connect(this, &PackageManagerCore::startAllComponentsReset, [&] { + d->m_defaultModel->reset(); + }); + connect(this, &PackageManagerCore::finishAllComponentsReset, d->m_defaultModel, + &ComponentModel::reset); } - connect(this, &PackageManagerCore::finishAllComponentsReset, d->m_defaultModel, - &ComponentModel::setRootComponents); return d->m_defaultModel; } @@ -2183,40 +2644,70 @@ ComponentModel *PackageManagerCore::updaterComponentModel() const if (!d->m_updaterModel) { d->m_updaterModel = componentModel(const_cast<PackageManagerCore*> (this), QLatin1String("UpdaterComponentsModel")); + + connect(this, &PackageManagerCore::startUpdaterComponentsReset, [&] { + d->m_updaterModel->reset(); + }); + connect(this, &PackageManagerCore::finishUpdaterComponentsReset, d->m_updaterModel, + &ComponentModel::reset); } - connect(this, &PackageManagerCore::finishUpdaterComponentsReset, d->m_updaterModel, - &ComponentModel::setRootComponents); return d->m_updaterModel; } /*! + Returns the proxy model +*/ + +ComponentSortFilterProxyModel *PackageManagerCore::componentSortFilterProxyModel() +{ + if (!d->m_componentSortFilterProxyModel) { + d->m_componentSortFilterProxyModel = new ComponentSortFilterProxyModel(this); + d->m_componentSortFilterProxyModel->setRecursiveFilteringEnabled(true); + d->m_componentSortFilterProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive); + } + return d->m_componentSortFilterProxyModel; +} + +/*! Lists available packages filtered with \a regexp without GUI. Virtual components are not listed unless set visible. Optionally, a \a filters hash containing package information elements and regular expressions can be used to further filter listed packages. + Returns \c true if matching packages were found, \c false otherwise. + \sa setVirtualComponentsVisible() */ -void PackageManagerCore::listAvailablePackages(const QString ®exp, const QHash<QString, QString> &filters) +bool PackageManagerCore::listAvailablePackages(const QString ®exp, const QHash<QString, QString> &filters) { setPackageViewer(); + d->enableAllCategories(); qCDebug(QInstaller::lcInstallerInstallLog) << "Searching packages with regular expression:" << regexp; ComponentModel *model = defaultComponentModel(); - d->fetchMetaInformationFromRepositories(DownloadType::UpdatesXML); + PackagesList packages; - d->addUpdateResourcesFromRepositories(true); - QRegularExpression re(regexp); - const PackagesList &packages = d->remotePackages(); - if (!fetchAllPackages(packages, LocalPackagesHash())) { - qCWarning(QInstaller::lcInstallerInstallLog) - << "There was a problem with loading the package data."; - return; + if (!d->m_updates) { + d->fetchMetaInformationFromRepositories(); + d->addUpdateResourcesFromRepositories(); + + packages = d->remotePackages(); + if (!fetchAllPackages(packages, LocalPackagesMap())) { + qCWarning(QInstaller::lcInstallerInstallLog) + << "There was a problem with loading the package data."; + return false; + } + } else { + // No need to fetch metadata again + packages = d->remotePackages(); } + QRegularExpression re(regexp); + re.setPatternOptions(QRegularExpression::CaseInsensitiveOption); + PackagesList matchedPackages; - foreach (Package *package, packages) { + foreach (Package *package, qAsConst(packages)) { const QString name = package->data(scName).toString(); Component *component = componentByName(name); if (!component) @@ -2228,6 +2719,7 @@ void PackageManagerCore::listAvailablePackages(const QString ®exp, const QHas for (auto &key : filters.keys()) { const QString elementValue = component->value(key); QRegularExpression elementRegexp(filters.value(key)); + elementRegexp.setPatternOptions(QRegularExpression::CaseInsensitiveOption); if (elementValue.isEmpty() || !elementRegexp.match(elementValue).hasMatch()) { ignoreComponent = true; break; @@ -2237,10 +2729,68 @@ void PackageManagerCore::listAvailablePackages(const QString ®exp, const QHas matchedPackages.append(package); } } - if (matchedPackages.count() == 0) + if (matchedPackages.count() == 0) { qCDebug(QInstaller::lcInstallerInstallLog) << "No matching packages found."; - else - LoggingHandler::instance().printPackageInformation(matchedPackages, localInstalledPackages()); + return false; + } + + LoggingHandler::instance().printPackageInformation(matchedPackages, localInstalledPackages()); + return true; +} + +/*! + Lists available component aliases filtered with \a regexp without GUI. Virtual + aliases are not listed unless set visible. + + Returns \c true if matching package aliases were found, \c false otherwise. + + \sa setVirtualComponentsVisible() +*/ +bool PackageManagerCore::listAvailableAliases(const QString ®exp) +{ + setPackageViewer(); + d->enableAllCategories(); + qCDebug(QInstaller::lcInstallerInstallLog) + << "Searching aliases with regular expression:" << regexp; + + ComponentModel *model = defaultComponentModel(); + Q_UNUSED(model); + + if (!d->m_updates) { + d->fetchMetaInformationFromRepositories(); + d->addUpdateResourcesFromRepositories(); + + const PackagesList &packages = d->remotePackages(); + if (!fetchAllPackages(packages, LocalPackagesMap())) { + qCWarning(QInstaller::lcInstallerInstallLog) + << "There was a problem with loading the package data."; + return false; + } + } + + QRegularExpression re(regexp); + re.setPatternOptions(QRegularExpression::CaseInsensitiveOption); + + QList<ComponentAlias *> matchedAliases; + for (auto *alias : qAsConst(d->m_componentAliases)) { + if (!alias) + continue; + + if (re.match(alias->name()).hasMatch() && !alias->isUnstable()) { + if (alias->isVirtual() && !virtualComponentsVisible()) + continue; + + matchedAliases.append(alias); + } + } + + if (matchedAliases.isEmpty()) { + qCDebug(QInstaller::lcInstallerInstallLog) << "No matching package aliases found."; + return false; + } + + LoggingHandler::instance().printAliasInformation(matchedAliases); + return true; } bool PackageManagerCore::componentUninstallableFromCommandLine(const QString &componentName) @@ -2254,7 +2804,7 @@ bool PackageManagerCore::componentUninstallableFromCommandLine(const QString &co } ComponentModel *model = defaultComponentModel(); const QModelIndex &idx = model->indexFromComponentName(component->treeName()); - if (model->data(idx, Qt::CheckStateRole) == QVariant::Invalid) { + if (model->data(idx, Qt::CheckStateRole) == QVariant()) { // Component cannot be unselected, check why if (component->forcedInstallation()) { qCWarning(QInstaller::lcInstallerInstallLog).noquote().nospace() @@ -2278,35 +2828,58 @@ bool PackageManagerCore::componentUninstallableFromCommandLine(const QString &co /*! \internal - Tries to set \c Qt::CheckStateRole to \c Qt::Checked for given \a components in the - default component model. Returns \c true if \a components contains at least one component + Tries to set \c Qt::CheckStateRole to \c Qt::Checked for given component \a names in the + default component model, and select given aliases in the \c names list. + + Returns \c true if \a names contains at least one component or component alias eligible for installation, otherwise returns \c false. An error message can be retrieved with \a errorMessage. */ -bool PackageManagerCore::checkComponentsForInstallation(const QStringList &components, QString &errorMessage) +bool PackageManagerCore::checkComponentsForInstallation(const QStringList &names, QString &errorMessage, bool &unstableAliasFound) { bool installComponentsFound = false; ComponentModel *model = defaultComponentModel(); - foreach (const QString &name, components) { + foreach (const QString &name, names) { Component *component = componentByName(name); if (!component) { - errorMessage.append(tr("Cannot install %1. Component not found.\n").arg(name)); + // No such component, check if we have an alias by the name + if (ComponentAlias *alias = aliasByName(name)) { + if (alias->isUnstable()) { + errorMessage.append(tr("Cannot select alias %1. There was a problem loading this alias, " + "so it is marked unstable and cannot be selected.").arg(name) + QLatin1Char('\n')); + unstableAliasFound = true; + continue; + } else if (alias->isVirtual()) { + errorMessage.append(tr("Cannot select %1. Alias is marked virtual, meaning it cannot " + "be selected manually.").arg(name) + QLatin1Char('\n')); + continue; + } + + alias->setSelected(true); + installComponentsFound = true; + } else { + errorMessage.append(tr("Cannot install %1. Component not found.").arg(name) + QLatin1Char('\n')); + } + continue; } const QModelIndex &idx = model->indexFromComponentName(component->treeName()); if (idx.isValid()) { - if ((model->data(idx, Qt::CheckStateRole) == QVariant::Invalid) && !component->forcedInstallation()) { + if ((model->data(idx, Qt::CheckStateRole) == QVariant()) && !component->forcedInstallation()) { // User cannot select the component, check why if (component->autoDependencies().count() > 0) { errorMessage.append(tr("Cannot install component %1. Component is installed only as automatic " - "dependency to %2.\n").arg(name, component->autoDependencies().join(QLatin1Char(',')))); + "dependency to %2.").arg(name, component->autoDependencies().join(QLatin1Char(','))) + QLatin1Char('\n')); } else if (!component->isCheckable()) { errorMessage.append(tr("Cannot install component %1. Component is not checkable, meaning you " - "have to select one of the subcomponents.\n").arg(name)); + "have to select one of the subcomponents.").arg(name) + QLatin1Char('\n')); + } else if (component->isUnstable()) { + errorMessage.append(tr("Cannot install component %1. There was a problem loading this component, " + "so it is marked unstable and cannot be selected.").arg(name) + QLatin1Char('\n')); } } else if (component->isInstalled()) { - errorMessage.append(tr("Component %1 already installed\n").arg(name)); + errorMessage.append(tr("Component %1 already installed").arg(name) + QLatin1Char('\n')); } else { model->setData(idx, Qt::Checked, Qt::CheckStateRole); installComponentsFound = true; @@ -2321,16 +2894,16 @@ bool PackageManagerCore::checkComponentsForInstallation(const QStringList &compo return false; } else if (trace->isVirtual()) { errorMessage.append(tr("Cannot install %1. Component is a descendant " - "of a virtual component %2.\n").arg(name, trace->name())); + "of a virtual component %2.").arg(name, trace->name()) + QLatin1Char('\n')); return true; } } }; // idx is invalid and component valid when we have invisible virtual component if (component->isVirtual()) - errorMessage.append(tr("Cannot install %1. Component is virtual.\n").arg(name)); + errorMessage.append(tr("Cannot install %1. Component is virtual.").arg(name) + QLatin1Char('\n')); else if (!isDescendantOfVirtual()) - errorMessage.append(tr("Cannot install %1. Component not found.\n").arg(name)); + errorMessage.append(tr("Cannot install %1. Component not found.").arg(name) + QLatin1Char('\n')); } } if (!installComponentsFound) @@ -2345,14 +2918,14 @@ bool PackageManagerCore::checkComponentsForInstallation(const QStringList &compo void PackageManagerCore::listInstalledPackages(const QString ®exp) { setPackageViewer(); - LocalPackagesHash installedPackages = this->localInstalledPackages(); + LocalPackagesMap installedPackages = this->localInstalledPackages(); if (!regexp.isEmpty()) { qCDebug(QInstaller::lcInstallerInstallLog) << "Searching packages with regular expression:" << regexp; } - const QRegularExpression re(regexp); - + QRegularExpression re(regexp); + re.setPatternOptions(QRegularExpression::CaseInsensitiveOption); const QStringList &keys = installedPackages.keys(); QList<LocalPackage> packages; foreach (const QString &key, keys) { @@ -2363,6 +2936,25 @@ void PackageManagerCore::listInstalledPackages(const QString ®exp) LoggingHandler::instance().printLocalPackageInformation(packages); } +PackageManagerCore::Status PackageManagerCore::searchAvailableUpdates() +{ + setUpdater(); + d->enableAllCategories(); + if (!fetchRemotePackagesTree()) { + qCWarning(QInstaller::lcInstallerInstallLog) << error(); + return status(); + } + + const QList<QInstaller::Component *> availableUpdates = + components(QInstaller::PackageManagerCore::ComponentType::Root); + if (availableUpdates.isEmpty()) { + qCWarning(QInstaller::lcInstallerInstallLog) << "There are currently no updates available."; + return status(); + } + QInstaller::LoggingHandler::instance().printUpdateInformation(availableUpdates); + return status(); +} + /*! Updates the selected components \a componentsToUpdate without GUI. If essential components are found, then only those will be updated. @@ -2370,13 +2962,25 @@ void PackageManagerCore::listInstalledPackages(const QString ®exp) */ PackageManagerCore::Status PackageManagerCore::updateComponentsSilently(const QStringList &componentsToUpdate) { - if (d->runningProcessesFound()) - throw Error(tr("Running processes found.")); setUpdater(); ComponentModel *model = updaterComponentModel(); - fetchRemotePackagesTree(); + if (componentsToUpdate.isEmpty()) { + d->enableAllCategories(); + fetchRemotePackagesTree(); + } else { + bool fallbackReposFetched = false; + bool packagesFound = fetchPackagesWithFallbackRepositories(componentsToUpdate, fallbackReposFetched); + + if (!packagesFound) { + qCDebug(QInstaller::lcInstallerInstallLog).noquote().nospace() + << "No components available for update with the current selection."; + d->setStatus(Canceled); + return status(); + } + } + // List contains components containing update, if essential found contains only essential component const QList<QInstaller::Component*> componentList = componentsMarkedForInstallation(); @@ -2482,15 +3086,44 @@ void PackageManagerCore::addLicenseItem(const QHash<QString, QVariantMap> &licen } } +bool PackageManagerCore::hasLicenses() const +{ + foreach (Component* component, orderedComponentsToInstall()) { + if (isMaintainer() && component->isInstalled()) + continue; // package manager or updater, hide as long as the component is installed + + // The component is about to be installed and provides a license, so the page needs to + // be shown. + if (!component->licenses().isEmpty()) + return true; + } + return false; +} + +/*! + * Adds \a component local \a dependencies to a hash table for quicker search for + * uninstall dependency components. + */ +void PackageManagerCore::createLocalDependencyHash(const QString &component, const QString &dependencies) const +{ + d->createLocalDependencyHash(component, dependencies); +} + +/*! + * Adds \a component \a newDependencies to a hash table for quicker search for + * install and uninstall autodependency components. Removes \a oldDependencies + * from the hash table if dependencies have changed. + */ +void PackageManagerCore::createAutoDependencyHash(const QString &component, const QString &oldDependencies, const QString &newDependencies) const +{ + d->createAutoDependencyHash(component, oldDependencies, newDependencies); +} /*! Uninstalls the selected components \a components without GUI. Returns PackageManagerCore installation status. */ PackageManagerCore::Status PackageManagerCore::uninstallComponentsSilently(const QStringList& components) { - if (d->runningProcessesFound()) - throw Error(tr("Running processes found.")); - if (components.isEmpty()) { qCDebug(QInstaller::lcInstallerInstallLog) << "No components selected for uninstallation."; return PackageManagerCore::Canceled; @@ -2529,8 +3162,6 @@ PackageManagerCore::Status PackageManagerCore::uninstallComponentsSilently(const PackageManagerCore::Status PackageManagerCore::removeInstallationSilently() { setCompleteUninstallation(true); - if (d->runningProcessesFound()) - throw Error(tr("Running processes found.")); qCDebug(QInstaller::lcInstallerInstallLog) << "Complete uninstallation was chosen."; if (!(d->m_autoConfirmCommand || d->askUserConfirmCommand())) { @@ -2552,22 +3183,7 @@ PackageManagerCore::Status PackageManagerCore::removeInstallationSilently() PackageManagerCore::Status PackageManagerCore::createOfflineInstaller(const QStringList &componentsToAdd) { setOfflineGenerator(); - // init default model before fetching remote packages tree - ComponentModel *model = defaultComponentModel(); - Q_UNUSED(model); - if (!fetchRemotePackagesTree()) - return status(); - - QString errorMessage; - if (checkComponentsForInstallation(componentsToAdd, errorMessage)) { - if (d->calculateComponentsAndRun()) { - qCDebug(QInstaller::lcInstallerInstallLog) - << "Created installer to:" << offlineBinaryName(); - } - } else { - qCDebug(QInstaller::lcInstallerInstallLog).noquote().nospace() << errorMessage; - } - return status(); + return d->fetchComponentsAndInstall(componentsToAdd); } /*! @@ -2579,13 +3195,10 @@ PackageManagerCore::Status PackageManagerCore::createOfflineInstaller(const QStr PackageManagerCore::Status PackageManagerCore::installSelectedComponentsSilently(const QStringList& components) { if (!isInstaller()) { - // Check if there are processes running in the install if maintenancetool is used. - if (d->runningProcessesFound()) - throw Error(tr("Running processes found.")); setPackageManager(); //Check that packages are not already installed - const LocalPackagesHash installedPackages = this->localInstalledPackages(); + const LocalPackagesMap installedPackages = this->localInstalledPackages(); QStringList helperStrList; helperStrList << components << installedPackages.keys(); helperStrList.removeDuplicates(); @@ -2594,21 +3207,7 @@ PackageManagerCore::Status PackageManagerCore::installSelectedComponentsSilently return PackageManagerCore::Canceled; } } - - // init default model before fetching remote packages tree - ComponentModel *model = defaultComponentModel(); - Q_UNUSED(model); - if (!fetchRemotePackagesTree()) - return status(); - - QString errorMessage; - if (checkComponentsForInstallation(components, errorMessage)) { - if (d->calculateComponentsAndRun()) - qCDebug(QInstaller::lcInstallerInstallLog) << "Components installed successfully"; - } else { - qCDebug(QInstaller::lcInstallerInstallLog).noquote().nospace() << errorMessage; - } - return status(); + return d->fetchComponentsAndInstall(components); } /*! @@ -2674,6 +3273,21 @@ void PackageManagerCore::dropAdminRights() } /*! + Returns \c true if the installer has admin rights. For example, if the installer + was started with a root account, or the internal admin rights elevation is active. + + Returns \c false otherwise. + + \sa {installer::hasAdminRights}{installer.hasAdminRights} + \sa gainAdminRights() + \sa dropAdminRights() +*/ +bool PackageManagerCore::hasAdminRights() const +{ + return AdminAuthorization::hasAdminRights() || RemoteClient::instance().isActive(); +} + +/*! Sets checkAvailableSpace based on value of \a check. */ void PackageManagerCore::setCheckAvailableSpace(bool check) @@ -2682,12 +3296,22 @@ void PackageManagerCore::setCheckAvailableSpace(bool check) } /*! - Checks available disk space if the feature is not explicitly disabled. Informative - text about space status can be retrieved by passing \a message parameter. Returns + * Returns informative text about disk space status + */ +QString PackageManagerCore::availableSpaceMessage() const +{ + return m_availableSpaceMessage; +} + +/*! + Checks available disk space if the feature is not explicitly disabled. Returns \c true if there is sufficient free space on installation and temporary volumes. + + \sa availableSpaceMessage() */ -bool PackageManagerCore::checkAvailableSpace(QString &message) const +bool PackageManagerCore::checkAvailableSpace() { + m_availableSpaceMessage.clear(); const quint64 extraSpace = 256 * 1024 * 1024LL; quint64 required(requiredDiskSpace()); quint64 tempRequired(requiredTemporaryDiskSpace()); @@ -2715,10 +3339,10 @@ bool PackageManagerCore::checkAvailableSpace(QString &message) const << humanReadableSize(repositorySize); if (d->m_checkAvailableSpace) { - const VolumeInfo tempVolume = VolumeInfo::fromPath(QDir::tempPath()); + const VolumeInfo cacheVolume = VolumeInfo::fromPath(settings().localCachePath()); const VolumeInfo targetVolume = VolumeInfo::fromPath(value(scTargetDir)); - const quint64 tempVolumeAvailableSize = tempVolume.availableSize(); + const quint64 cacheVolumeAvailableSize = cacheVolume.availableSize(); const quint64 installVolumeAvailableSize = targetVolume.availableSize(); // at the moment there is no better way to check this @@ -2729,58 +3353,62 @@ bool PackageManagerCore::checkAvailableSpace(QString &message) const return true; } - const bool tempOnSameVolume = (targetVolume == tempVolume); - if (tempOnSameVolume) { - qDebug() << "Tmp and install directories are on the same volume. Volume mount point:" + const bool cacheOnSameVolume = (targetVolume == cacheVolume); + if (cacheOnSameVolume) { + qDebug() << "Cache and install directories are on the same volume. Volume mount point:" << targetVolume.mountPath() << "Free space available:" << humanReadableSize(installVolumeAvailableSize); } else { - qDebug() << "Tmp is on a different volume than the installation directory. Tmp volume mount point:" - << tempVolume.mountPath() << "Free space available:" - << humanReadableSize(tempVolumeAvailableSize) << "Install volume mount point:" + qDebug() << "Cache is on a different volume than the installation directory. Cache volume mount point:" + << cacheVolume.mountPath() << "Free space available:" + << humanReadableSize(cacheVolumeAvailableSize) << "Install volume mount point:" << targetVolume.mountPath() << "Free space available:" << humanReadableSize(installVolumeAvailableSize); } - if (tempOnSameVolume && (installVolumeAvailableSize <= (required + tempRequired))) { - message = tr("Not enough disk space to store temporary files and the " + if (cacheOnSameVolume && (installVolumeAvailableSize <= (required + tempRequired))) { + m_availableSpaceMessage = tr("Not enough disk space to store temporary files and the " "installation. %1 are available, while the minimum required is %2.").arg( humanReadableSize(installVolumeAvailableSize), humanReadableSize(required + tempRequired)); return false; } if (installVolumeAvailableSize < required) { - message = tr("Not enough disk space to store all selected components! %1 are " + m_availableSpaceMessage = tr("Not enough disk space to store all selected components! %1 are " "available, while the minimum required is %2.").arg(humanReadableSize(installVolumeAvailableSize), humanReadableSize(required)); return false; } - if (tempVolumeAvailableSize < tempRequired) { - message = tr("Not enough disk space to store temporary files! %1 are available, " - "while the minimum required is %2.").arg(humanReadableSize(tempVolumeAvailableSize), - humanReadableSize(tempRequired)); + if (cacheVolumeAvailableSize < tempRequired) { + m_availableSpaceMessage = tr("Not enough disk space to store temporary files! %1 are available, " + "while the minimum required is %2. You may select another location for the " + "temporary files by modifying the local cache path from the installer settings.") + .arg(humanReadableSize(cacheVolumeAvailableSize), humanReadableSize(tempRequired)); return false; } if (installVolumeAvailableSize - required < 0.01 * targetVolume.size()) { // warn for less than 1% of the volume's space being free - message = tr("The volume you selected for installation seems to have sufficient space for " + m_availableSpaceMessage = tr("The volume you selected for installation seems to have sufficient space for " "installation, but there will be less than 1% of the volume's space available afterwards."); } else if (installVolumeAvailableSize - required < 100 * 1024 * 1024LL) { // warn for less than 100MB being free - message = tr("The volume you selected for installation seems to have sufficient " + m_availableSpaceMessage = tr("The volume you selected for installation seems to have sufficient " "space for installation, but there will be less than 100 MB available afterwards."); } #ifdef Q_OS_WIN if (isOfflineGenerator() && (required > UINT_MAX)) { - message = tr("The estimated installer size %1 would exceed the supported executable " + m_availableSpaceMessage = tr("The estimated installer size %1 would exceed the supported executable " "size limit of %2. The application may not be able to run.") .arg(humanReadableSize(required), humanReadableSize(UINT_MAX)); } #endif } - message = QString::fromLatin1("%1 %2").arg(message, tr("Installation will use %1 of disk space.") + m_availableSpaceMessage = QString::fromLatin1("%1 %2").arg(m_availableSpaceMessage, + (isOfflineGenerator() + ? tr("Created installer will use %1 of disk space.") + : tr("Installation will use %1 of disk space.")) .arg(humanReadableSize(requiredDiskSpace()))).simplified(); return true; @@ -2839,6 +3467,10 @@ bool PackageManagerCore::killProcess(const QString &absoluteFilePath) const } /*! + \deprecated [4.6] Maintenance tool no longer automatically checks for all running processes + in the installation directory for CLI runs. To manually check for a process to stop, use + \l {component::addStopProcessForUpdateRequest}{component.addStopProcessForUpdateRequest} instead. + Sets additional \a processes that can run when updating with the maintenance tool. @@ -2850,6 +3482,10 @@ void PackageManagerCore::setAllowedRunningProcesses(const QStringList &processes } /*! + \deprecated [4.6] Maintenance tool no longer automatically checks for all running processes + in the installation directory for CLI runs. To manually check for a process to stop, use + \l {component::addStopProcessForUpdateRequest}{component.addStopProcessForUpdateRequest} instead. + Returns processes that are allowed to run when updating with the maintenance tool. @@ -3057,9 +3693,10 @@ bool PackageManagerCore::performOperation(const QString &name, const QStringList */ bool PackageManagerCore::versionMatches(const QString &version, const QString &requirement) { - QRegExp compEx(QLatin1String("([<=>]+)(.*)")); - const QString comparator = compEx.exactMatch(requirement) ? compEx.cap(1) : QLatin1String("="); - const QString ver = compEx.exactMatch(requirement) ? compEx.cap(2) : requirement; + static const QRegularExpression compEx(QLatin1String("^([<=>]+)(.*)$")); + const QRegularExpressionMatch match = compEx.match(requirement); + const QString comparator = match.hasMatch() ? match.captured(1) : QLatin1String("="); + const QString ver = match.hasMatch() ? match.captured(2) : requirement; const bool allowEqual = comparator.contains(QLatin1Char('=')); const bool allowLess = comparator.contains(QLatin1Char('<')); @@ -3155,6 +3792,17 @@ void PackageManagerCore::setInstallerBaseBinary(const QString &path) } /*! + Returns the value of \c installerbase binary which is used when writing + the maintenance tool. Value can be empty. + + \sa setInstallerBaseBinary() +*/ +QString PackageManagerCore::installerBaseBinary() const +{ + return d->m_installerBaseBinaryUnreplaced; +} + +/*! Sets the \c installerbase binary located at \a path to use when writing the offline installer. Setting this makes it possible to run the offline generator in cases where we are not running a real installer, i.e. when executing autotests. @@ -3177,14 +3825,18 @@ void PackageManagerCore::addResourcesForOfflineGeneration(const QString &rcPath) /*! Returns the installer value for \a key. If \a key is not known to the system, \a defaultValue is - returned. Additionally, on Windows, \a key can be a registry key. + returned. Additionally, on Windows, \a key can be a registry key. Optionally, you can specify the + \a format of the registry key. By default the \a format is QSettings::NativeFormat. + For accessing the 32-bit system registry from a 64-bit application running on 64-bit Windows, + use QSettings::Registry32Format. For accessing the 64-bit system registry from a 32-bit + application running on 64-bit Windows, use QSettings::Registry64Format. \sa {installer::value}{installer.value} \sa setValue(), containsValue(), valueChanged() */ -QString PackageManagerCore::value(const QString &key, const QString &defaultValue) const +QString PackageManagerCore::value(const QString &key, const QString &defaultValue, const int &format) const { - return d->m_data.value(key, defaultValue).toString(); + return d->m_data.value(key, defaultValue, static_cast<QSettings::Format>(format)).toString(); } /*! @@ -3349,6 +4001,14 @@ QString PackageManagerCore::offlineBinaryName() const } /*! + Add new \a source for looking component aliases. +*/ +void PackageManagerCore::addAliasSource(const AliasSource &source) +{ + d->m_aliasSources.insert(source); +} + +/*! \sa {installer::setInstaller}{installer.setInstaller} \sa isInstaller(), setUpdater(), setPackageManager() */ @@ -3407,6 +4067,7 @@ bool PackageManagerCore::isUninstaller() const void PackageManagerCore::setUpdater() { d->m_magicBinaryMarker = BinaryContent::MagicUpdaterMarker; + d->m_componentByNameHash.clear(); emit installerBinaryMarkerChanged(d->m_magicBinaryMarker); } @@ -3427,6 +4088,7 @@ bool PackageManagerCore::isUpdater() const void PackageManagerCore::setPackageManager() { d->m_magicBinaryMarker = BinaryContent::MagicPackageManagerMarker; + d->m_componentByNameHash.clear(); emit installerBinaryMarkerChanged(d->m_magicBinaryMarker); } @@ -3448,6 +4110,7 @@ bool PackageManagerCore::isPackageManager() const void PackageManagerCore::setOfflineGenerator() { d->m_magicMarkerSupplement = BinaryContent::OfflineGenerator; + emit installerBinaryMarkerChanged(d->m_magicBinaryMarker); } /*! @@ -3466,6 +4129,7 @@ bool PackageManagerCore::isOfflineGenerator() const void PackageManagerCore::setPackageViewer() { d->m_magicMarkerSupplement = BinaryContent::PackageViewer; + emit installerBinaryMarkerChanged(d->m_magicBinaryMarker); } /*! @@ -3479,6 +4143,17 @@ bool PackageManagerCore::isPackageViewer() const } /*! + Resets the binary marker supplement of the installer to \c Default. + The supplement enables or disables additional features on top of the binary + marker state (\c Installer, \c Updater, \c PackageManager, \c Uninstaller). +*/ +void PackageManagerCore::resetBinaryMarkerSupplement() +{ + d->m_magicMarkerSupplement = BinaryContent::Default; + emit installerBinaryMarkerChanged(d->m_magicBinaryMarker); +} + +/*! Sets the installer magic binary marker based on \a magicMarker and userSetBinaryMarker to \c true. */ @@ -3615,55 +4290,56 @@ bool PackageManagerCore::updateComponentData(struct Data &data, Component *compo try { // Check if we already added the component to the available components list. // Component treenames and names must be unique. - QString name = data.package->data(scTreeName).toString(); - if (name.isEmpty()) - name = data.package->data(scName).toString(); + const QString packageName = data.package->data(scName).toString(); + const QString packageTreeName = data.package->data(scTreeName).value<QPair<QString, bool>>().first; + + QString name = packageTreeName.isEmpty() ? packageName : packageTreeName; if (data.components->contains(name)) { - d->setStatus(Failure, tr("Cannot register component! Component with identifier %1 " - "already exists.").arg(name)); - return false; + qCritical() << "Cannot register component" << packageName << "with name" << name + << "! Component with identifier" << name << "already exists."; + // Conflicting original name, skip. + if (packageTreeName.isEmpty()) + return false; + + // Conflicting tree name, check if we can add with original name. + if (!settings().allowUnstableComponents() || data.components->contains(packageName)) + return false; + + qCDebug(lcInstallerInstallLog) + << "Registering component with the original indetifier:" << packageName; + + component->removeValue(scTreeName); + const QString errorString = QLatin1String("Tree name conflicts with an existing indentifier"); + d->m_pendingUnstableComponents.insert(component->name(), + QPair<Component::UnstableError, QString>(Component::InvalidTreeName, errorString)); } - name = data.package->data(scName).toString(); + name = packageName; if (settings().allowUnstableComponents()) { // Check if there are sha checksum mismatch. Component will still show in install tree // but is unselectable. - foreach (const QString packageName, d->m_metadataJob.shaMismatchPackages()) { - if (packageName == component->name()) { - QString errorString = QLatin1String("SHA mismatch detected for component ") + packageName; - component->setUnstable(Component::UnstableError::ShaMismatch, errorString); + foreach (const QString pkgName, d->m_metadataJob.shaMismatchPackages()) { + if (pkgName == component->name()) { + const QString errorString = QLatin1String("SHA mismatch detected for component ") + pkgName; + d->m_pendingUnstableComponents.insert(component->name(), + QPair<Component::UnstableError, QString>(Component::ShaMismatch, errorString)); } } } component->setUninstalled(); const QString localPath = component->localTempPath(); - if (LoggingHandler::instance().verboseLevel() == LoggingHandler::Detailed) { - static QString lastLocalPath; - if (lastLocalPath != localPath) - qCDebug(QInstaller::lcDeveloperBuild()) << "Url is:" << localPath; - lastLocalPath = localPath; - } - - const Repository repo = d->m_metadataJob.repositoryForDirectory(localPath); + const Repository repo = d->m_metadataJob.repositoryForCacheDirectory(localPath); if (repo.isValid()) { component->setRepositoryUrl(repo.url()); component->setValue(QLatin1String("username"), repo.username()); component->setValue(QLatin1String("password"), repo.password()); } - // add downloadable archive from xml - const QStringList downloadableArchives = data.package->data(scDownloadableArchives).toString() - .split(QInstaller::commaRegExp(), QString::SkipEmptyParts); - - if (component->isFromOnlineRepository()) { - foreach (const QString downloadableArchive, downloadableArchives) - component->addDownloadableArchive(downloadableArchive); - } - - const QStringList componentsToReplace = data.package->data(scReplaces).toString() - .split(QInstaller::commaRegExp(), QString::SkipEmptyParts); + if (component->isFromOnlineRepository()) + component->addDownloadableArchives(data.package->data(scDownloadableArchives).toString()); + const QStringList componentsToReplace = QInstaller::splitStringWithComma(data.package->data(scReplaces).toString()); if (!componentsToReplace.isEmpty()) { // Store the component (this is a component that replaces others) and all components that // this one will replace. @@ -3681,6 +4357,8 @@ bool PackageManagerCore::updateComponentData(struct Data &data, Component *compo // a possible component to replace that might be installed (to mark the replacement as installed). component->setInstalled(); component->setValue(scInstalledVersion, data.installedPackages->value(name).version); + component->setValue(scLocalDependencies, data.installedPackages->value(name). + dependencies.join(QLatin1String(","))); return true; } @@ -3688,8 +4366,8 @@ bool PackageManagerCore::updateComponentData(struct Data &data, Component *compo foreach (const QString &componentName, componentsToReplace) { if (data.installedPackages->contains(componentName)) { // We found a replacement that is installed. - if (isPackageManager()) { - // Mark the replacement component as installed as well. Only do this in package manager + if (isUpdater()) { + // Mark the replacement component as installed as well. Only do this in updater // mode, otherwise it would not show up in the updaters component list. component->setInstalled(); component->setValue(scInstalledVersion, data.installedPackages->value(componentName).version); @@ -3704,13 +4382,21 @@ bool PackageManagerCore::updateComponentData(struct Data &data, Component *compo return true; } -void PackageManagerCore::storeReplacedComponents(QHash<QString, Component *> &components, const struct Data &data) +void PackageManagerCore::storeReplacedComponents(QHash<QString, Component *> &components, + const struct Data &data, QMap<QString, QString> *const treeNameComponents) { QHash<Component*, QStringList>::const_iterator it = data.replacementToExchangeables.constBegin(); // remember all components that got a replacement, required for uninstall for (; it != data.replacementToExchangeables.constEnd(); ++it) { foreach (const QString &componentName, it.value()) { - Component *componentToReplace = components.take(componentName); + QString key = componentName; + if (treeNameComponents && treeNameComponents->contains(componentName)) { + // The exchangeable component is stored with a tree name key, + // remove from the list of components with tree name. + key = treeNameComponents->value(componentName); + treeNameComponents->remove(componentName); + } + Component *componentToReplace = components.value(key); if (!componentToReplace) { // If a component replaces another component which is not existing in the // installer binary or the installed component list, just ignore it. This @@ -3719,180 +4405,283 @@ void PackageManagerCore::storeReplacedComponents(QHash<QString, Component *> &co qCWarning(QInstaller::lcDeveloperBuild) << componentName << "- Does not exist in the repositories anymore."; continue; } - if (!d->componentsToReplace().contains(componentName)) { - componentToReplace = new Component(this); - componentToReplace->setValue(scName, componentName); - } else { - // This case can happen when in installer mode as well, a component - // is in the installer binary and its replacement component as well. - d->replacementDependencyComponents().append(componentToReplace); + // Remove the replaced component from instal tree if + // 1. Running installer (component is replaced by other component) + // 2. Replacement is already installed but replacable is not + // Do not remove the replaced component from install tree + // in updater so that would show as an update + // Also do not remove the replaced component from install tree + // if it is already installed together with replacable component, + // otherwise it does not match what we have defined in components.xml + if (!isUpdater() + && (isInstaller() || (it.key() && it.key()->isInstalled() && !componentToReplace->isInstalled()))) { + components.remove(key); + d->m_deletedReplacedComponents.append(componentToReplace); } + d->replacementDependencyComponents().append(componentToReplace); + + //Following hashes are created for quicker search of components d->componentsToReplace().insert(componentName, qMakePair(it.key(), componentToReplace)); + QStringList oldValue = d->componentReplaces().value(it.key()->name()); + d->componentReplaces().insert(it.key()->name(), oldValue << componentToReplace->name()); } } } -bool PackageManagerCore::fetchAllPackages(const PackagesList &remotes, const LocalPackagesHash &locals) +bool PackageManagerCore::fetchAllPackages(const PackagesList &remotes, const LocalPackagesMap &locals) { emit startAllComponentsReset(); - d->clearAllComponentLists(); - QHash<QString, QInstaller::Component*> components; + try { + d->clearAllComponentLists(); + QHash<QString, QInstaller::Component*> allComponents; - Data data; - data.components = &components; - data.installedPackages = &locals; + Data data; + data.components = &allComponents; + data.installedPackages = &locals; - QMap<QString, QString> treeNameComponents; - foreach (Package *const package, remotes) { - if (d->statusCanceledOrFailed()) - return false; + QMap<QString, QString> remoteTreeNameComponents; + QMap<QString, QString> allTreeNameComponents; - if (!ProductKeyCheck::instance()->isValidPackage(package->data(scName).toString())) - continue; + std::function<bool(PackagesList *, bool)> loadRemotePackages; + loadRemotePackages = [&](PackagesList *treeNamePackages, bool firstRun) -> bool { + foreach (Package *const package, (firstRun ? remotes : *treeNamePackages)) { + if (d->statusCanceledOrFailed()) + return false; - QScopedPointer<QInstaller::Component> component(new QInstaller::Component(this)); - data.package = package; - component->loadDataFromPackage(*package); - if (updateComponentData(data, component.data())) { - // Create a list where is name and treename. Repo can contain a package with - // a different treename of component which is already installed. We don't want - // to move already installed local packages. - const QString treeName = component->value(scTreeName); - if (!treeName.isEmpty()) - treeNameComponents.insert(component->name(), treeName); - QString name = component->treeName(); - components.insert(name, component.take()); - } else { - return false; + if (!ProductKeyCheck::instance()->isValidPackage(package->data(scName).toString())) + continue; + + if (firstRun && !package->data(scTreeName) + .value<QPair<QString, bool>>().first.isEmpty()) { + // Package has a tree name, leave for later + treeNamePackages->append(package); + continue; + } + + std::unique_ptr<QInstaller::Component> remoteComponent(new QInstaller::Component(this)); + data.package = package; + remoteComponent->loadDataFromPackage(*package); + if (updateComponentData(data, remoteComponent.get())) { + // Create a list where is name and treename. Repo can contain a package with + // a different treename of component which is already installed. We don't want + // to move already installed local packages. + const QString treeName = remoteComponent->value(scTreeName); + if (!treeName.isEmpty()) + remoteTreeNameComponents.insert(remoteComponent->name(), treeName); + const QString name = remoteComponent->treeName(); + allComponents.insert(name, remoteComponent.release()); + } + } + // Second pass with leftover packages + return firstRun ? loadRemotePackages(treeNamePackages, false) : true; + }; + + { + // Loading remote package data is performed in two steps: first, components without + // - and then components with tree names. This is to ensure components with tree + // names do not replace other components when registering fails to a name conflict. + PackagesList treeNamePackagesTmp; + if (!loadRemotePackages(&treeNamePackagesTmp, true)) + return false; } - } + allTreeNameComponents = remoteTreeNameComponents; - foreach (const QString &key, locals.keys()) { - QScopedPointer<QInstaller::Component> component(new QInstaller::Component(this)); - component->loadDataFromPackage(locals.value(key)); - QString treeName = component->treeName(); - - // 1. Component has a treename in local but not in remote - if (!treeNameComponents.contains(component->name()) && !component->value(scTreeName).isEmpty()) { - Component *comp = components.take(component->name()); - delete comp; - components.insert(treeName, component.take()); - // 2. Component has different treename in local and remote, add with local treename - } else if (treeNameComponents.contains(component->name())) { - QString remoteTreeName = treeNameComponents.value(component->name()); - QString componentTreeName = component->value(scTreeName); - if (remoteTreeName != componentTreeName) { - Component *comp = components.take(treeNameComponents.value(component->name())); - delete comp; - components.insert(treeName, component.take()); + foreach (auto &package, locals) { + if (package.virtualComp && package.autoDependencies.isEmpty()) { + if (!d->m_localVirtualComponents.contains(package.name)) + d->m_localVirtualComponents.append(package.name); } - // 3. Component has same treename in local and remote, don't add the component again. - } else if (!components.contains(treeName)) { - components.insert(treeName, component.take()); + + std::unique_ptr<QInstaller::Component> localComponent(new QInstaller::Component(this)); + localComponent->loadDataFromPackage(package); + const QString name = localComponent->treeName(); + + // 1. Component has a treename in local but not in remote, add with local treename + if (!remoteTreeNameComponents.contains(localComponent->name()) && !localComponent->value(scTreeName).isEmpty()) { + delete allComponents.take(localComponent->name()); + // 2. Component has different treename in local and remote, add with local treename + } else if (remoteTreeNameComponents.contains(localComponent->name())) { + const QString remoteTreeName = remoteTreeNameComponents.value(localComponent->name()); + const QString localTreeName = localComponent->value(scTreeName); + if (remoteTreeName != localTreeName) { + delete allComponents.take(remoteTreeNameComponents.value(localComponent->name())); + } else { + // 3. Component has same treename in local and remote, don't add the component again. + continue; + } + // 4. Component does not have treename in local or remote, don't add the component again. + } else if (allComponents.contains(localComponent->name())) { + Component *const component = allComponents.value(localComponent->name()); + if (component->value(scTreeName).isEmpty() && localComponent->value(scTreeName).isEmpty()) + continue; + } + // 5. Remote has treename for a different component that is already reserved + // by this local component, Or, remote adds component without treename + // but it conflicts with a local treename. + if (allComponents.contains(name)) { + const QString key = remoteTreeNameComponents.key(name); + qCritical() << "Cannot register component" << (key.isEmpty() ? name : key) + << "with name" << name << "! Component with identifier" << name + << "already exists."; + + if (!key.isEmpty()) + allTreeNameComponents.remove(key); + + // Try to re-add the remote component as unstable + if (!key.isEmpty() && !allComponents.contains(key) && settings().allowUnstableComponents()) { + qCDebug(lcInstallerInstallLog) + << "Registering component with the original indetifier:" << key; + + Component *component = allComponents.take(name); + component->removeValue(scTreeName); + const QString errorString = QLatin1String("Tree name conflicts with an existing indentifier"); + d->m_pendingUnstableComponents.insert(component->name(), + QPair<Component::UnstableError, QString>(Component::InvalidTreeName, errorString)); + + allComponents.insert(key, component); + } else { + delete allComponents.take(name); + } + } + + const QString treeName = localComponent->value(scTreeName); + if (!treeName.isEmpty()) + allTreeNameComponents.insert(localComponent->name(), treeName); + allComponents.insert(name, localComponent.release()); } - } - // store all components that got a replacement - storeReplacedComponents(components, data); + // store all components that got a replacement + storeReplacedComponents(allComponents, data, &allTreeNameComponents); + + // Move children of treename components + createAutoTreeNames(allComponents, allTreeNameComponents); + + if (!d->buildComponentTree(allComponents, true)) + return false; + + d->commitPendingUnstableComponents(); - if (!d->buildComponentTree(components, true)) + if (!d->buildComponentAliases()) + return false; + + } catch (const Error &error) { + d->clearAllComponentLists(); + d->setStatus(PackageManagerCore::Failure, error.message()); + + // TODO: make sure we remove all message boxes inside the library at some point. + MessageBoxHandler::critical(MessageBoxHandler::currentBestSuitParent(), QLatin1String("Error"), + tr("Error"), error.message()); return false; + } emit finishAllComponentsReset(d->m_rootComponents); return true; } -bool PackageManagerCore::fetchUpdaterPackages(const PackagesList &remotes, const LocalPackagesHash &locals) +bool PackageManagerCore::fetchUpdaterPackages(const PackagesList &remotes, const LocalPackagesMap &locals) { emit startUpdaterComponentsReset(); - d->clearUpdaterComponentLists(); - QHash<QString, QInstaller::Component *> components; + try { + d->clearUpdaterComponentLists(); + QHash<QString, QInstaller::Component *> components; - Data data; - data.components = &components; - data.installedPackages = &locals; + Data data; + data.components = &components; + data.installedPackages = &locals; - setFoundEssentialUpdate(false); - LocalPackagesHash installedPackages = locals; - QStringList replaceMes; + setFoundEssentialUpdate(false); + LocalPackagesMap installedPackages = locals; + QStringList replaceMes; - foreach (Package *const update, remotes) { - if (d->statusCanceledOrFailed()) - return false; + foreach (Package *const update, remotes) { + if (d->statusCanceledOrFailed()) + return false; - if (!ProductKeyCheck::instance()->isValidPackage(update->data(scName).toString())) - continue; + if (!ProductKeyCheck::instance()->isValidPackage(update->data(scName).toString())) + continue; - QScopedPointer<QInstaller::Component> component(new QInstaller::Component(this)); - data.package = update; - component->loadDataFromPackage(*update); - if (updateComponentData(data, component.data())) { - // Keep a reference so we can resolve dependencies during update. - d->m_updaterComponentsDeps.append(component.take()); - -// const QString isNew = update->data(scNewComponent).toString(); -// if (isNew.toLower() != scTrue) -// continue; - - const QString &name = d->m_updaterComponentsDeps.last()->name(); - const QString replaces = data.package->data(scReplaces).toString(); - installedPackages.take(name); // remove from local installed packages - - bool isValidUpdate = locals.contains(name); - if (!isValidUpdate && !replaces.isEmpty()) { - const QStringList possibleNames = replaces.split(QInstaller::commaRegExp(), - QString::SkipEmptyParts); - foreach (const QString &possibleName, possibleNames) { - if (locals.contains(possibleName)) { - isValidUpdate = true; - replaceMes << possibleName; + std::unique_ptr<QInstaller::Component> component(new QInstaller::Component(this)); + data.package = update; + component->loadDataFromPackage(*update); + if (updateComponentData(data, component.get())) { + // Keep a reference so we can resolve dependencies during update. + d->m_updaterComponentsDeps.append(component.release()); + + // const QString isNew = update->data(scNewComponent).toString(); + // if (isNew.toLower() != scTrue) + // continue; + + const QString &name = d->m_updaterComponentsDeps.last()->name(); + const QString replaces = data.package->data(scReplaces).toString(); + installedPackages.take(name); // remove from local installed packages + + bool isValidUpdate = locals.contains(name); + if (!replaces.isEmpty()) { + const QStringList possibleNames = replaces.split(QInstaller::commaRegExp(), + Qt::SkipEmptyParts); + foreach (const QString &possibleName, possibleNames) { + if (locals.contains(possibleName)) { + isValidUpdate = true; + replaceMes << possibleName; + } } } - } - // break if the update is not valid and if it's not the maintenance tool (we might get an update - // for the maintenance tool even if it's not currently installed - possible offline installation) - if (!isValidUpdate && (update->data(scEssential, scFalse).toString().toLower() == scFalse)) - continue; // Update for not installed package found, skip it. - - const LocalPackage &localPackage = locals.value(name); - if (!d->packageNeedsUpdate(localPackage, update)) - continue; - // It is quite possible that we may have already installed the update. Lets check the last - // update date of the package and the release date of the update. This way we can compare and - // figure out if the update has been installed or not. - const QDate updateDate = update->data(scReleaseDate).toDate(); - if (localPackage.lastUpdateDate > updateDate) - continue; + // break if the update is not valid and if it's not the maintenance tool (we might get an update + // for the maintenance tool even if it's not currently installed - possible offline installation) + if (!isValidUpdate && (update->data(scEssential, scFalse).toString().toLower() == scFalse)) + continue; // Update for not installed package found, skip it. + + const LocalPackage &localPackage = locals.value(name); + if (!d->packageNeedsUpdate(localPackage, update)) + continue; + // It is quite possible that we may have already installed the update. Lets check the last + // update date of the package and the release date of the update. This way we can compare and + // figure out if the update has been installed or not. + const QDate updateDate = update->data(scReleaseDate).toDate(); + if (localPackage.lastUpdateDate > updateDate) + continue; + + if (update->data(scEssential, scFalse).toString().toLower() == scTrue || + update->data(scForcedUpdate, scFalse).toString().toLower() == scTrue) { + setFoundEssentialUpdate(true); + } - if (update->data(scEssential, scFalse).toString().toLower() == scTrue || - update->data(scForcedUpdate, scFalse).toString().toLower() == scTrue) { - setFoundEssentialUpdate(true); + // this is not a dependency, it is a real update + components.insert(name, d->m_updaterComponentsDeps.takeLast()); } + } - // this is not a dependency, it is a real update - components.insert(name, d->m_updaterComponentsDeps.takeLast()); - } else { - return false; + QHash<QString, QInstaller::Component *> localReplaceMes; + foreach (const QString &key, installedPackages.keys()) { + QInstaller::Component *component = new QInstaller::Component(this); + component->loadDataFromPackage(installedPackages.value(key)); + d->m_updaterComponentsDeps.append(component); } - } - QHash<QString, QInstaller::Component *> localReplaceMes; - foreach (const QString &key, installedPackages.keys()) { - QInstaller::Component *component = new QInstaller::Component(this); - component->loadDataFromPackage(installedPackages.value(key)); - d->m_updaterComponentsDeps.append(component); - // Keep a list of local components that should be replaced - if (replaceMes.contains(component->name())) - localReplaceMes.insert(component->name(), component); - } + foreach (const QString &key, locals.keys()) { + LocalPackage package = locals.value(key); + if (package.virtualComp && package.autoDependencies.isEmpty()) { + if (!d->m_localVirtualComponents.contains(package.name)) + d->m_localVirtualComponents.append(package.name); + } + // Keep a list of local components that should be replaced + // Remove from components list - we don't want to update the component + // as it is replaced by other component + if (replaceMes.contains(key)) { + QInstaller::Component *component = new QInstaller::Component(this); + component->loadDataFromPackage(locals.value(key)); + localReplaceMes.insert(component->name(), component); + delete components.take(component->name()); + } + } - // store all components that got a replacement, but do not modify the components list - storeReplacedComponents(localReplaceMes.unite(components), data); + // store all components that got a replacement, but do not modify the components list + localReplaceMes.insert(components); + storeReplacedComponents(localReplaceMes, data); - try { if (!components.isEmpty()) { // append all components w/o parent to the direct list foreach (QInstaller::Component *component, components) { @@ -3900,21 +4689,25 @@ bool PackageManagerCore::fetchUpdaterPackages(const PackagesList &remotes, const } // after everything is set up, load the scripts + if (!d->loadComponentScripts(components)) + return false; + foreach (QInstaller::Component *component, components) { if (d->statusCanceledOrFailed()) return false; - component->loadComponentScript(); if (!component->isUnstable()) component->setCheckState(Qt::Checked); } + // even for possible dependencies we need to load the scripts for example to get archives + if (!d->loadComponentScripts(d->m_updaterComponentsDeps)) + return false; + // after everything is set up, check installed components foreach (QInstaller::Component *component, d->m_updaterComponentsDeps) { if (d->statusCanceledOrFailed()) return false; - // even for possible dependency we need to load the script for example to get archives - component->loadComponentScript(); if (component->isInstalled()) { // since we do not put them into the model, which would force a update of e.g. tri state // components, we have to check all installed components ourselves @@ -3922,7 +4715,6 @@ bool PackageManagerCore::fetchUpdaterPackages(const PackagesList &remotes, const component->setCheckState(Qt::Checked); } } - if (foundEssentialUpdate()) { foreach (QInstaller::Component *component, components) { if (d->statusCanceledOrFailed()) @@ -3950,7 +4742,6 @@ bool PackageManagerCore::fetchUpdaterPackages(const PackagesList &remotes, const } } catch (const Error &error) { d->clearUpdaterComponentLists(); - emit finishUpdaterComponentsReset(QList<QInstaller::Component*>()); d->setStatus(Failure, error.message()); // TODO: make sure we remove all message boxes inside the library at some point. @@ -3963,6 +4754,80 @@ bool PackageManagerCore::fetchUpdaterPackages(const PackagesList &remotes, const return true; } +/*! + \internal + + Creates automatic tree names for \a components that have a parent declaring + an explicit tree name. The child components keep the relative location + to their parent component. + + The \a treeNameComponents is a map of original component names and new tree names. +*/ +void PackageManagerCore::createAutoTreeNames(QHash<QString, Component *> &components + , const QMap<QString, QString> &treeNameComponents) +{ + if (treeNameComponents.isEmpty()) + return; + + QHash<QString, Component *> componentsTemp; + QMutableHashIterator<QString, Component* > i(components); + while (i.hasNext()) { + i.next(); + Component *component = i.value(); + if (component->treeName() != component->name()) // already handled + continue; + + QString newName; + // Check treename candidates, keep the name closest to a leaf component + QMap<QString, QString>::const_iterator j; + for (j = treeNameComponents.begin(); j != treeNameComponents.end(); ++j) { + const QString name = j.key(); + if (!component->name().startsWith(name)) + continue; + + const Component *parent = components.value(treeNameComponents.value(name)); + if (!(parent && parent->treeNameMoveChildren())) + continue; // TreeName only applied to parent + + if (newName.split(QLatin1Char('.'), Qt::SkipEmptyParts).count() + > name.split(QLatin1Char('.'), Qt::SkipEmptyParts).count()) { + continue; + } + newName = name; + } + if (newName.isEmpty()) // Nothing to do + continue; + + const QString treeName = component->name() + .replace(newName, treeNameComponents.value(newName)); + + if (components.contains(treeName) || treeNameComponents.contains(treeName)) { + // Can happen if the parent was moved to an existing identifier (which did not + // have a component) and contains child that has a conflicting name with a component + // in the existing branch. + qCritical() << "Cannot register component" << component->name() << "with automatic " + "tree name" << treeName << "! Component with identifier" << treeName << "already exists."; + + if (settings().allowUnstableComponents()) { + qCDebug(lcInstallerInstallLog) + << "Falling back to using the original indetifier:" << component->name(); + + const QString errorString = QLatin1String("Tree name conflicts with an existing indentifier"); + d->m_pendingUnstableComponents.insert(component->name(), + QPair<Component::UnstableError, QString>(Component::InvalidTreeName, errorString)); + } else { + i.remove(); + } + continue; + } + component->setValue(scAutoTreeName, treeName); + + i.remove(); + componentsTemp.insert(treeName, component); + } + components.insert(componentsTemp); +} + void PackageManagerCore::restoreCheckState() { d->restoreCheckState(); @@ -4027,8 +4892,6 @@ ComponentModel *PackageManagerCore::componentModel(PackageManagerCore *core, con ComponentModel::tr("Release Date")); model->setHeaderData(ComponentModelHelper::UncompressedSizeColumn, Qt::Horizontal, ComponentModel::tr("Size")); - connect(model, SIGNAL(checkStateChanged(QInstaller::ComponentModel::ModelState)), this, - SLOT(componentsToInstallNeedsRecalculation())); return model; } |