diff options
Diffstat (limited to 'src/libs/installer/packagemanagercore_p.cpp')
| -rw-r--r-- | src/libs/installer/packagemanagercore_p.cpp | 1295 |
1 files changed, 982 insertions, 313 deletions
diff --git a/src/libs/installer/packagemanagercore_p.cpp b/src/libs/installer/packagemanagercore_p.cpp index 51c044356..0ed4bf6d8 100644 --- a/src/libs/installer/packagemanagercore_p.cpp +++ b/src/libs/installer/packagemanagercore_p.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,7 +31,6 @@ #include "binarycontent.h" #include "binaryformatenginehandler.h" #include "binarylayout.h" -#include "component.h" #include "scriptengine.h" #include "componentmodel.h" #include "errors.h" @@ -46,19 +45,25 @@ #include "qsettingswrapper.h" #include "installercalculator.h" #include "uninstallercalculator.h" +#include "componentalias.h" #include "componentchecker.h" #include "globals.h" #include "binarycreator.h" #include "loggingutils.h" +#include "concurrentoperationrunner.h" +#include "remoteclient.h" +#include "operationtracer.h" #include "selfrestarter.h" #include "filedownloaderfactory.h" #include "updateoperationfactory.h" +#include "constants.h" #include <productkeycheck.h> #include <QSettings> #include <QtConcurrentRun> +#include <QtConcurrent> #include <QtCore/QCoreApplication> #include <QtCore/QDir> #include <QtCore/QDirIterator> @@ -87,36 +92,6 @@ namespace QInstaller { \internal */ -class OperationTracer -{ -public: - OperationTracer(Operation *operation) : m_operation(nullptr) - { - // don't create output for that hacky pseudo operation - if (operation->name() != QLatin1String("MinimumProgress")) - m_operation = operation; - } - void trace(const QString &state) - { - if (!m_operation) - return; - qCDebug(QInstaller::lcInstallerInstallLog).noquote() << QString::fromLatin1("%1 %2 operation: %3") - .arg(state, m_operation->value(QLatin1String("component")).toString(), m_operation->name()); - QStringList args = m_operation->arguments(); - if (m_operation->requiresUnreplacedVariables()) - args = m_operation->packageManager()->replaceVariables(m_operation->arguments()); - qCDebug(QInstaller::lcInstallerInstallLog).noquote() << QString::fromLatin1("\t- arguments: %1") - .arg(args.join(QLatin1String(", "))); - } - ~OperationTracer() { - if (!m_operation) - return; - qCDebug(QInstaller::lcInstallerInstallLog) << "Done"; - } -private: - Operation *m_operation; -}; - static bool runOperation(Operation *operation, Operation::OperationType type) { OperationTracer tracer(operation); @@ -148,84 +123,67 @@ static QStringList checkRunningProcessesFromList(const QStringList &processList) return stillRunningProcesses; } -static void deferredRename(const QString &oldName, const QString &newName, bool restart = false) +static bool filterMissingAliasesToInstall(const QString& component, const QList<ComponentAlias *> packages) { -#ifdef Q_OS_WIN - QStringList arguments; - - // Check if .vbs extension can be used for running renaming script. If not, create own extension - QString extension = QLatin1String(".vbs"); - QSettingsWrapper settingRoot(QLatin1String("HKEY_CLASSES_ROOT\\.vbs"), QSettingsWrapper::NativeFormat); - if (settingRoot.value(QLatin1String(".")).toString() != QLatin1String("VBSFile")) { - extension = QLatin1String(".qtInstaller"); - QSettingsWrapper settingsUser(QLatin1String("HKEY_CURRENT_USER\\Software\\Classes"), QSettingsWrapper::NativeFormat); - QString value = settingsUser.value(extension).toString(); - if (value != QLatin1String("VBSFile")) - settingsUser.setValue(extension, QLatin1String("VBSFile")); + bool packageFound = false; + for (qsizetype i = 0; i < packages.size(); ++i) { + packageFound = (packages.at(i)->name() == component); + if (packageFound) + break; } - QTemporaryFile f(QDir::temp().absoluteFilePath(QLatin1String("deferredrenameXXXXXX%1")).arg(extension)); - - QInstaller::openForWrite(&f); - f.setAutoRemove(false); - - arguments << QDir::toNativeSeparators(f.fileName()) << QDir::toNativeSeparators(oldName) - << QDir::toNativeSeparators(QFileInfo(oldName).dir().absoluteFilePath(QFileInfo(newName) - .fileName())); - - QTextStream batch(&f); - batch.setCodec("UTF-16"); - batch << "Set fso = WScript.CreateObject(\"Scripting.FileSystemObject\")\n"; - batch << "Set tmp = WScript.CreateObject(\"WScript.Shell\")\n"; - batch << QString::fromLatin1("file = \"%1\"\n").arg(arguments[2]); - batch << "on error resume next\n"; + return !packageFound; +} - batch << "while fso.FileExists(file)\n"; - batch << " fso.DeleteFile(file)\n"; - batch << " WScript.Sleep(1000)\n"; - batch << "wend\n"; - batch << QString::fromLatin1("fso.MoveFile \"%1\", file\n").arg(arguments[1]); - if (restart) { - //Restart with same command line arguments as first executable - QStringList commandLineArguments = QCoreApplication::arguments(); - batch << QString::fromLatin1("tmp.exec \"%1 --%2") - .arg(arguments[2]).arg(CommandLineOptions::scStartUpdaterLong); - //Skip the first argument as that is executable itself - for (int i = 1; i < commandLineArguments.count(); i++) { - batch << QString::fromLatin1(" %1").arg(commandLineArguments.at(i)); - } - batch << QString::fromLatin1("\"\n"); +static bool filterMissingPackagesToInstall(const QString& component, const PackagesList& packages) +{ + bool packageFound = false; + for (qsizetype i = 0; i < packages.size(); ++i) { + packageFound = (packages.at(i)->data(scName).toString() == component); + if (packageFound) + break; } - batch << "fso.DeleteFile(WScript.ScriptFullName)\n"; - - QProcessWrapper::startDetached(QLatin1String("cscript"), QStringList() << QLatin1String("//Nologo") - << arguments[0]); -#else - QFile::remove(newName); - QFile::rename(oldName, newName); - SelfRestarter::setRestartOnQuit(restart); -#endif + return !packageFound; } +static QString getAppBundlePath() { + QString appDirPath = QCoreApplication::applicationDirPath(); + QDir dir(appDirPath); + while (!dir.isRoot()) { + if (dir.dirName().endsWith(QLatin1String(".app"))) + return dir.absolutePath(); + dir.cdUp(); + } + return QString(); +} // -- PackageManagerCorePrivate PackageManagerCorePrivate::PackageManagerCorePrivate(PackageManagerCore *core) : m_updateFinder(nullptr) + , m_aliasFinder(nullptr) , m_localPackageHub(std::make_shared<LocalPackageHub>()) , m_status(PackageManagerCore::Unfinished) , m_needsHardRestart(false) , m_testChecksum(false) , m_launchedAsRoot(AdminAuthorization::hasAdminRights()) + , m_commandLineInstance(false) + , m_defaultInstall(false) + , m_userSetBinaryMarker(false) + , m_checkAvailableSpace(true) , m_completeUninstall(false) , m_needToWriteMaintenanceTool(false) , m_dependsOnLocalInstallerBinary(false) + , m_autoAcceptLicenses(false) + , m_disableWriteMaintenanceTool(false) + , m_autoConfirmCommand(false) , m_core(core) , m_updates(false) + , m_aliases(false) , m_repoFetched(false) , m_updateSourcesAdded(false) , m_magicBinaryMarker(0) // initialize with pseudo marker , m_magicMarkerSupplement(BinaryContent::Default) - , m_componentsToInstallCalculated(false) + , m_foundEssentialUpdate(false) , m_componentScriptEngine(nullptr) , m_controlScriptEngine(nullptr) , m_installerCalculator(nullptr) @@ -233,37 +191,46 @@ PackageManagerCorePrivate::PackageManagerCorePrivate(PackageManagerCore *core) , m_proxyFactory(nullptr) , m_defaultModel(nullptr) , m_updaterModel(nullptr) + , m_componentSortFilterProxyModel(nullptr) , m_guiObject(nullptr) , m_remoteFileEngineHandler(nullptr) - , m_foundEssentialUpdate(false) - , m_commandLineInstance(false) - , m_defaultInstall(false) - , m_userSetBinaryMarker(false) - , m_checkAvailableSpace(true) - , m_autoAcceptLicenses(false) - , m_disableWriteMaintenanceTool(false) - , m_autoConfirmCommand(false) + , m_datFileName(QString()) +#ifdef INSTALLCOMPRESSED + , m_allowCompressedRepositoryInstall(true) +#else + , m_allowCompressedRepositoryInstall(false) +#endif + , m_connectedOperations(0) { } PackageManagerCorePrivate::PackageManagerCorePrivate(PackageManagerCore *core, qint64 magicInstallerMaker, - const QList<OperationBlob> &performedOperations) + const QList<OperationBlob> &performedOperations, const QString &datFileName) : m_updateFinder(nullptr) + , m_aliasFinder(nullptr) , m_localPackageHub(std::make_shared<LocalPackageHub>()) , m_status(PackageManagerCore::Unfinished) , m_needsHardRestart(false) , m_testChecksum(false) , m_launchedAsRoot(AdminAuthorization::hasAdminRights()) + , m_commandLineInstance(false) + , m_defaultInstall(false) + , m_userSetBinaryMarker(false) + , m_checkAvailableSpace(true) , m_completeUninstall(false) , m_needToWriteMaintenanceTool(false) , m_dependsOnLocalInstallerBinary(false) + , m_autoAcceptLicenses(false) + , m_disableWriteMaintenanceTool(false) + , m_autoConfirmCommand(false) , m_core(core) , m_updates(false) + , m_aliases(false) , m_repoFetched(false) , m_updateSourcesAdded(false) , m_magicBinaryMarker(magicInstallerMaker) , m_magicMarkerSupplement(BinaryContent::Default) - , m_componentsToInstallCalculated(false) + , m_foundEssentialUpdate(false) , m_componentScriptEngine(nullptr) , m_controlScriptEngine(nullptr) , m_installerCalculator(nullptr) @@ -271,21 +238,21 @@ PackageManagerCorePrivate::PackageManagerCorePrivate(PackageManagerCore *core, q , m_proxyFactory(nullptr) , m_defaultModel(nullptr) , m_updaterModel(nullptr) + , m_componentSortFilterProxyModel(nullptr) , m_guiObject(nullptr) , m_remoteFileEngineHandler(new RemoteFileEngineHandler) - , m_foundEssentialUpdate(false) - , m_commandLineInstance(false) - , m_defaultInstall(false) - , m_userSetBinaryMarker(false) - , m_checkAvailableSpace(true) - , m_autoAcceptLicenses(false) - , m_disableWriteMaintenanceTool(false) - , m_autoConfirmCommand(false) + , m_datFileName(datFileName) +#ifdef INSTALLCOMPRESSED + , m_allowCompressedRepositoryInstall(true) +#else + , m_allowCompressedRepositoryInstall(false) +#endif + , m_connectedOperations(0) { foreach (const OperationBlob &operation, performedOperations) { - QScopedPointer<QInstaller::Operation> op(KDUpdater::UpdateOperationFactory::instance() + std::unique_ptr<QInstaller::Operation> op(KDUpdater::UpdateOperationFactory::instance() .create(operation.name, core)); - if (op.isNull()) { + if (!op) { qCWarning(QInstaller::lcInstallerInstallLog) << "Failed to load unknown operation" << operation.name; continue; @@ -296,7 +263,7 @@ PackageManagerCorePrivate::PackageManagerCorePrivate(PackageManagerCore *core, q << operation.name; continue; } - m_performedOperationsOld.append(op.take()); + m_performedOperationsOld.append(op.release()); } connect(this, &PackageManagerCorePrivate::installationStarted, @@ -325,6 +292,7 @@ PackageManagerCorePrivate::~PackageManagerCorePrivate() qDeleteAll(m_performedOperationsCurrentSession); delete m_updateFinder; + delete m_aliasFinder; delete m_proxyFactory; delete m_defaultModel; @@ -366,7 +334,8 @@ bool PackageManagerCorePrivate::isProcessRunning(const QString &name, } /* static */ -bool PackageManagerCorePrivate::performOperationThreaded(Operation *operation, Operation::OperationType type) +bool PackageManagerCorePrivate::performOperationThreaded(Operation *operation, + Operation::OperationType type) { QFutureWatcher<bool> futureWatcher; const QFuture<bool> future = QtConcurrent::run(runOperation, operation, type); @@ -427,11 +396,10 @@ bool PackageManagerCorePrivate::buildComponentTree(QHash<QString, Component*> &c m_core->appendRootComponent(component); } - // after everything is set up, load the scripts if needed - if (loadScript) { - foreach (QInstaller::Component *component, components) - component->loadComponentScript(); - } + // after everything is set up, load the scripts if needed and create helper hashes + // for autodependency and dependency components for quicker search later + if (loadScript && !loadComponentScripts(components)) + return false; // now we can preselect components in the tree foreach (QInstaller::Component *component, components) { @@ -456,10 +424,10 @@ bool PackageManagerCorePrivate::buildComponentTree(QHash<QString, Component*> &c component->setCheckState(Qt::Checked); clearInstallerCalculator(); - if (installerCalculator()->appendComponentsToInstall(components.values()) == false) { - setStatus(PackageManagerCore::Failure, installerCalculator()->componentsToInstallError()); + if (installerCalculator()->solve(components.values()) == false) { + setStatus(PackageManagerCore::Failure, installerCalculator()->error()); MessageBoxHandler::critical(MessageBoxHandler::currentBestSuitParent(), QLatin1String("Error"), - tr("Unresolved dependencies"), installerCalculator()->componentsToInstallError()); + tr("Unresolved dependencies"), installerCalculator()->error()); return false; } @@ -475,7 +443,6 @@ bool PackageManagerCorePrivate::buildComponentTree(QHash<QString, Component*> &c } catch (const Error &error) { clearAllComponentLists(); - emit m_core->finishAllComponentsReset(QList<QInstaller::Component*>()); setStatus(PackageManagerCore::Failure, error.message()); // TODO: make sure we remove all message boxes inside the library at some point. @@ -486,8 +453,154 @@ bool PackageManagerCorePrivate::buildComponentTree(QHash<QString, Component*> &c return true; } +bool PackageManagerCorePrivate::buildComponentAliases() +{ + // For now, aliases are only used for command line runs + if (!m_core->isCommandLineInstance()) + return true; + + { + const QList<ComponentAlias *> aliasList = componentAliases(); + if (aliasList.isEmpty()) + return true; + + for (const auto *alias : aliasList) { + // Create a new alias object for package manager core to take ownership of + ComponentAlias *newAlias = new ComponentAlias(m_core); + for (const QString &key : alias->keys()) + newAlias->setValue(key, alias->value(key)); + + m_componentAliases.insert(alias->name(), newAlias); + } + } + + if (m_core->isPackageViewer()) + return true; + // After aliases are loaded, perform sanity checks: + + // 1. Component check state is changed by alias selection, so store the initial state + storeCheckState(); + + QStringList aliasNamesSelectedForInstall; + + // 2. Get a list of alias names to be installed, dependency aliases needs to be listed first + // to get proper unstable state for parents + std::function<void(QStringList)> fetchAliases = [&](QStringList aliases) { + for (const QString &aliasName : aliases) { + ComponentAlias *alias = m_componentAliases.value(aliasName); + if (!alias || aliasNamesSelectedForInstall.contains(aliasName)) + continue; + if (!aliasNamesSelectedForInstall.contains(aliasName)) + aliasNamesSelectedForInstall.prepend(aliasName); + fetchAliases(QStringList() << QInstaller::splitStringWithComma(alias->value(scRequiredAliases)) + << QInstaller::splitStringWithComma(alias->value(scOptionalAliases))); + } + }; + for (const QString &installComponent : m_componentsToBeInstalled) { + ComponentAlias *alias = m_componentAliases.value(installComponent); + if (!alias) + continue; + if (!aliasNamesSelectedForInstall.contains(installComponent)) + aliasNamesSelectedForInstall.prepend(installComponent); + fetchAliases(QStringList() << QInstaller::splitStringWithComma(alias->value(scRequiredAliases)) + << QInstaller::splitStringWithComma(alias->value(scOptionalAliases))); + } + + Graph<QString> aliasGraph; + QList<ComponentAlias *> aliasesSelectedForInstall; + for (auto &aliasName : std::as_const(aliasNamesSelectedForInstall)) { + ComponentAlias *alias = m_componentAliases.value(aliasName); + if (!alias) + continue; + aliasGraph.addNode(alias->name()); + aliasGraph.addEdges(alias->name(), + QInstaller::splitStringWithComma(alias->value(scRequiredAliases)) << + QInstaller::splitStringWithComma(alias->value(scOptionalAliases))); + + if (!m_core->componentByName(alias->name())) { + // Name ok, select for sanity check calculation + alias->setSelected(true); + } else { + alias->setUnstable(ComponentAlias::ComponentNameConfict, + tr("Alias declares name that conflicts with an existing component \"%1\"") + .arg(alias->name())); + } + if (!aliasesSelectedForInstall.contains(alias)) + aliasesSelectedForInstall.append(alias); + } + + const QList<QString> sortedAliases = aliasGraph.sort(); + // 3. Check for cyclic dependency errors + if (aliasGraph.hasCycle()) { + setStatus(PackageManagerCore::Failure, installerCalculator()->error()); + MessageBoxHandler::critical(MessageBoxHandler::currentBestSuitParent(), QLatin1String("Error"), + tr("Unresolved component aliases"), + tr("Cyclic dependency between aliases \"%1\" and \"%2\" detected.") + .arg(aliasGraph.cycle().first, aliasGraph.cycle().second)); + + return false; + } + + // 4. Test for required aliases and components, this triggers setting the + // alias unstable in case of a broken reference. + for (const auto &aliasName : sortedAliases) { + ComponentAlias *alias = m_componentAliases.value(aliasName); + if (!alias) // sortedAliases may contain dependencies that don't exist, we don't know it yet + continue; + + alias->components(); + alias->aliases(); + } + + clearInstallerCalculator(); + // 5. Check for other errors preventing resolving components to install + if (!installerCalculator()->solve(aliasesSelectedForInstall)) { + setStatus(PackageManagerCore::Failure, installerCalculator()->error()); + MessageBoxHandler::critical(MessageBoxHandler::currentBestSuitParent(), QLatin1String("Error"), + tr("Unresolved component aliases"), installerCalculator()->error()); + + return false; + } + + for (auto *alias : std::as_const(m_componentAliases)) + alias->setSelected(false); + + // 6. Restore original state + restoreCheckState(); + + return true; +} + +template <typename T> +bool PackageManagerCorePrivate::loadComponentScripts(const T &components, const bool postScript) +{ + infoMessage(nullptr, tr("Loading component scripts...")); + + quint64 loadedComponents = 0; + for (auto *component : components) { + if (statusCanceledOrFailed()) + return false; + + component->loadComponentScript(postScript); + ++loadedComponents; + + const int currentProgress = qRound(double(loadedComponents) / components.count() * 100); + infoProgress(nullptr, currentProgress, 100); + qApp->processEvents(); + } + return true; +} + +template bool PackageManagerCorePrivate::loadComponentScripts<QList<Component *>>(const QList<Component *> &, const bool); +template bool PackageManagerCorePrivate::loadComponentScripts<QHash<QString, Component *>>(const QHash<QString, Component *> &, const bool); + void PackageManagerCorePrivate::cleanUpComponentEnvironment() { + m_componentReplaces.clear(); + m_autoDependencyComponentHash.clear(); + m_localDependencyComponentHash.clear(); + m_localVirtualComponents.clear(); + m_componentByNameHash.clear(); // clean up registered (downloaded) data if (m_core->isMaintainer()) BinaryFormatEngineHandler::instance()->clear(); @@ -496,6 +609,10 @@ void PackageManagerCorePrivate::cleanUpComponentEnvironment() // so we need to remove the current component script engine delete m_componentScriptEngine; m_componentScriptEngine = nullptr; + + // Calculators become invalid after clearing components + clearInstallerCalculator(); + clearUninstallerCalculator(); } ScriptEngine *PackageManagerCorePrivate::componentScriptEngine() const @@ -514,18 +631,18 @@ ScriptEngine *PackageManagerCorePrivate::controlScriptEngine() const void PackageManagerCorePrivate::clearAllComponentLists() { + qDeleteAll(m_componentAliases); + m_componentAliases.clear(); + QList<QInstaller::Component*> toDelete; - toDelete << m_rootComponents; + toDelete << m_rootComponents << m_deletedReplacedComponents; m_rootComponents.clear(); - m_rootDependencyReplacements.clear(); + m_deletedReplacedComponents.clear(); - const QList<QPair<Component*, Component*> > list = m_componentsToReplaceAllMode.values(); - for (int i = 0; i < list.count(); ++i) - toDelete << list.at(i).second; m_componentsToReplaceAllMode.clear(); - m_componentsToInstallCalculated = false; + m_foundEssentialUpdate = false; qDeleteAll(toDelete); cleanUpComponentEnvironment(); @@ -533,8 +650,10 @@ void PackageManagerCorePrivate::clearAllComponentLists() void PackageManagerCorePrivate::clearUpdaterComponentLists() { - QSet<Component*> usedComponents = - QSet<Component*>::fromList(m_updaterComponents + m_updaterComponentsDeps); + + QSet<Component*> usedComponents(m_updaterComponents.begin(), m_updaterComponents.end()); + usedComponents.unite(QSet<Component*>(m_updaterComponentsDeps.begin(), + m_updaterComponentsDeps.end())); const QList<QPair<Component*, Component*> > list = m_componentsToReplaceUpdaterMode.values(); for (int i = 0; i < list.count(); ++i) { @@ -550,7 +669,7 @@ void PackageManagerCorePrivate::clearUpdaterComponentLists() m_updaterDependencyReplacements.clear(); m_componentsToReplaceUpdaterMode.clear(); - m_componentsToInstallCalculated = false; + m_foundEssentialUpdate = false; qDeleteAll(usedComponents); cleanUpComponentEnvironment(); @@ -566,6 +685,11 @@ QHash<QString, QPair<Component*, Component*> > &PackageManagerCorePrivate::compo return (!isUpdater()) ? m_componentsToReplaceAllMode : m_componentsToReplaceUpdaterMode; } +QHash<QString, QStringList> &PackageManagerCorePrivate::componentReplaces() +{ + return m_componentReplaces; +} + void PackageManagerCorePrivate::clearInstallerCalculator() { delete m_installerCalculator; @@ -576,8 +700,7 @@ InstallerCalculator *PackageManagerCorePrivate::installerCalculator() const { if (!m_installerCalculator) { PackageManagerCorePrivate *const pmcp = const_cast<PackageManagerCorePrivate *> (this); - pmcp->m_installerCalculator = new InstallerCalculator( - m_core->components(PackageManagerCore::ComponentType::AllNoReplacements)); + pmcp->m_installerCalculator = new InstallerCalculator(m_core, pmcp->m_autoDependencyComponentHash); } return m_installerCalculator; } @@ -601,7 +724,8 @@ UninstallerCalculator *PackageManagerCorePrivate::uninstallerCalculator() const } } - pmcp->m_uninstallerCalculator = new UninstallerCalculator(installedComponents); + pmcp->m_uninstallerCalculator = new UninstallerCalculator(m_core, + pmcp->m_autoDependencyComponentHash, pmcp->m_localDependencyComponentHash, pmcp->m_localVirtualComponents); } return m_uninstallerCalculator; } @@ -610,10 +734,9 @@ void PackageManagerCorePrivate::initialize(const QHash<QString, QString> ¶ms { m_coreCheckedHash.clear(); m_data = PackageManagerCoreData(params, isInstaller()); - m_componentsToInstallCalculated = false; #ifdef Q_OS_LINUX - if (m_launchedAsRoot) + if (m_launchedAsRoot && isInstaller()) m_data.setValue(scTargetDir, replaceVariables(m_data.settings().adminTargetDir())); #endif @@ -668,11 +791,16 @@ void PackageManagerCorePrivate::initialize(const QHash<QString, QString> ¶ms m_localPackageHub->setApplicationVersion(QLatin1String(QUOTE(IFW_REPOSITORY_FORMAT_VERSION))); if (isInstaller()) - m_packageSources.insert(PackageSource(QUrl(QLatin1String("resource://metadata/")), 0)); + m_packageSources.insert(PackageSource(QUrl(QLatin1String("resource://metadata/")), 1)); + + const QString aliasFilePath = m_core->settings().aliasDefinitionsFile(); + if (!aliasFilePath.isEmpty()) + m_aliasSources.insert(AliasSource(AliasSource::SourceFileFormat::Xml, aliasFilePath, -1)); m_metadataJob.disconnect(); m_metadataJob.setAutoDelete(false); m_metadataJob.setPackageManagerCore(m_core); + connect(&m_metadataJob, &Job::infoMessage, this, &PackageManagerCorePrivate::infoMessage); connect(&m_metadataJob, &Job::progress, this, &PackageManagerCorePrivate::infoProgress); connect(&m_metadataJob, &Job::totalProgress, this, &PackageManagerCorePrivate::totalProgress); @@ -775,7 +903,12 @@ Operation *PackageManagerCorePrivate::takeOwnedOperation(Operation *operation) QString PackageManagerCorePrivate::maintenanceToolName() const { - QString filename = m_data.settings().maintenanceToolName(); + QString filename; + if (isInstaller()) + filename = m_data.settings().maintenanceToolName(); + else + filename = QCoreApplication::applicationName(); + #if defined(Q_OS_MACOS) if (QInstaller::isInBundle(QCoreApplication::applicationDirPath())) filename += QLatin1String(".app/Contents/MacOS/") + filename; @@ -785,6 +918,27 @@ QString PackageManagerCorePrivate::maintenanceToolName() const return QString::fromLatin1("%1/%2").arg(targetDir()).arg(filename); } +QString PackageManagerCorePrivate::maintenanceToolAliasPath() const +{ +#ifdef Q_OS_MACOS + const QString aliasName = m_data.settings().maintenanceToolAlias(); + if (aliasName.isEmpty()) + return QString(); + + const bool isRoot = m_core->hasAdminRights(); + const QString applicationsDir = m_core->value( + isRoot ? QLatin1String("ApplicationsDir") : QLatin1String("ApplicationsDirUser") + ); + QString maintenanceToolAlias = QString::fromLatin1("%1/%2") + .arg(applicationsDir, aliasName); + if (!maintenanceToolAlias.endsWith(QLatin1String(".app"))) + maintenanceToolAlias += QLatin1String(".app"); + + return maintenanceToolAlias; +#endif + return QString(); +} + QString PackageManagerCorePrivate::offlineBinaryName() const { QString filename = m_core->value(scOfflineBinaryName, qApp->applicationName() @@ -797,6 +951,13 @@ QString PackageManagerCorePrivate::offlineBinaryName() const return QString::fromLatin1("%1/%2").arg(targetDir()).arg(filename); } +QString PackageManagerCorePrivate::datFileName() +{ + if (m_datFileName.isEmpty()) + m_datFileName = targetDir() + QLatin1Char('/') + m_data.settings().maintenanceToolName() + QLatin1String(".dat"); + return m_datFileName; +} + static QNetworkProxy readProxy(QXmlStreamReader &reader) { QNetworkProxy proxy(QNetworkProxy::HttpProxy); @@ -850,12 +1011,12 @@ void PackageManagerCorePrivate::writeMaintenanceConfigFiles() QVariantHash variables; // Do not change to QVariantMap! Breaks existing .ini files, // cause the variant types do not match while restoring the variables from the file. - QSettingsWrapper cfg(iniPath, QSettingsWrapper::IniFormat); + QSettingsWrapper cfg(iniPath, QSettings::IniFormat); foreach (const QString &key, m_data.keys()) { if (key == scRunProgramDescription || key == scRunProgram || key == scRunProgramArguments) continue; QVariant value = m_data.value(key); - if (value.canConvert(QVariant::String)) + if (value.canConvert<QString>()) value = replacePath(value.toString(), targetDir(), QLatin1String(scRelocatable)); variables.insert(key, value); } @@ -879,8 +1040,8 @@ void PackageManagerCorePrivate::writeMaintenanceConfigFiles() QFile file(targetDir() + QLatin1Char('/') + QLatin1String("network.xml")); if (file.open(QIODevice::WriteOnly | QIODevice::Truncate)) { - QXmlStreamWriter writer(&file); - writer.setCodec("UTF-8"); + QString outputStr; + QXmlStreamWriter writer(&outputStr); writer.setAutoFormatting(true); writer.writeStartDocument(); @@ -911,7 +1072,10 @@ void PackageManagerCorePrivate::writeMaintenanceConfigFiles() writer.writeEndElement(); } writer.writeEndElement(); + writer.writeTextElement(QLatin1String("LocalCachePath"), m_data.settings().localCachePath()); writer.writeEndElement(); + + file.write(outputStr.toUtf8()); } setDefaultFilePermissions(&file, DefaultFilePermissions::NonExecutable); } @@ -919,7 +1083,7 @@ void PackageManagerCorePrivate::writeMaintenanceConfigFiles() void PackageManagerCorePrivate::readMaintenanceConfigFiles(const QString &targetDir) { QSettingsWrapper cfg(targetDir + QLatin1Char('/') + m_data.settings().maintenanceToolIniFile(), - QSettingsWrapper::IniFormat); + QSettings::IniFormat); const QVariantHash v = cfg.value(QLatin1String("Variables")).toHash(); // Do not change to // QVariantMap! Breaks reading from existing .ini files, cause the variant types do not match. for (QVariantHash::const_iterator it = v.constBegin(); it != v.constEnd(); ++it) { @@ -951,7 +1115,7 @@ void PackageManagerCorePrivate::readMaintenanceConfigFiles(const QString &target case QXmlStreamReader::StartElement: { if (reader.name() == QLatin1String("Network")) { while (reader.readNextStartElement()) { - const QStringRef name = reader.name(); + const QStringView name = reader.name(); if (name == QLatin1String("Ftp")) { m_data.settings().setFtpProxy(readProxy(reader)); } else if (name == QLatin1String("Http")) { @@ -960,6 +1124,8 @@ void PackageManagerCorePrivate::readMaintenanceConfigFiles(const QString &target m_data.settings().addUserRepositories(readRepositories(reader, false)); } else if (name == QLatin1String("ProxyType")) { m_data.settings().setProxyType(Settings::ProxyType(reader.readElementText().toInt())); + } else if (name == QLatin1String("LocalCachePath")) { + m_data.settings().setLocalCachePath(reader.readElementText()); } else { reader.skipCurrentElement(); } @@ -1058,8 +1224,11 @@ void PackageManagerCorePrivate::connectOperationToInstaller(Operation *const ope connect(m_core, SIGNAL(installationInterrupted()), operationObject, SLOT(cancelOperation())); if (mo->indexOfSignal(QMetaObject::normalizedSignature("progressChanged(double)")) > -1) { + // create unique object names for progress information track + operationObject->setObjectName(QLatin1String("operation_%1").arg(QString::number(m_connectedOperations))); ProgressCoordinator::instance()->registerPartProgress(operationObject, SIGNAL(progressChanged(double)), operationPartSize); + m_connectedOperations++; } } } @@ -1138,12 +1307,7 @@ void PackageManagerCorePrivate::writeMaintenanceToolBinary(QFile *const input, q // other code a lot (since installers don't have any appended data either) QFile dataOut(generateTemporaryFileName()); QInstaller::openForWrite(&dataOut); - QInstaller::appendInt64(&dataOut, 0); // operations start - QInstaller::appendInt64(&dataOut, 0); // operations end - QInstaller::appendInt64(&dataOut, 0); // resource count - QInstaller::appendInt64(&dataOut, 4 * sizeof(qint64)); // data block size - QInstaller::appendInt64(&dataOut, BinaryContent::MagicUninstallerMarker); - QInstaller::appendInt64(&dataOut, BinaryContent::MagicCookie); + QInstallerTools::createMTDatFile(dataOut); { QFile dummy(resourcePath.filePath(QLatin1String("installer.dat"))); @@ -1248,19 +1412,9 @@ void PackageManagerCorePrivate::writeMaintenanceToolBinaryData(QFileDevice *outp QInstaller::appendInt64(output, BinaryContent::MagicUninstallerMarker); } -void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOperations) +void PackageManagerCorePrivate::writeMaintenanceToolAppBundle(OperationList &performedOperations) { - if (m_disableWriteMaintenanceTool) { - qCDebug(QInstaller::lcInstallerInstallLog()) << "Maintenance tool writing disabled."; - return; - } - - bool gainedAdminRights = false; - if (!directoryWritable(targetDir())) { - m_core->gainAdminRights(); - gainedAdminRights = true; - } - +#ifdef Q_OS_MACOS const QString targetAppDirPath = QFileInfo(maintenanceToolName()).path(); if (!QDir().exists(targetAppDirPath)) { // create the directory containing the maintenance tool (like a bundle structure on macOS...) @@ -1270,8 +1424,6 @@ void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOper performOperationThreaded(op); performedOperations.append(takeOwnedOperation(op)); } - -#ifdef Q_OS_MACOS // if it is a bundle, we need some stuff in it... const QString sourceAppDirPath = QCoreApplication::applicationDirPath(); if (isInstaller() && QInstaller::isInBundle(sourceAppDirPath)) { @@ -1301,7 +1453,7 @@ void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOper const QString after = QLatin1String("<string>") + QFileInfo(maintenanceToolName()).baseName() + QLatin1String("</string>"); while (!in.atEnd()) - out << in.readLine().replace(before, after) << endl; + out << in.readLine().replace(before, after) << Qt::endl; // copy qt_menu.nib if it exists op = createOwnedOperation(QLatin1String("Mkdir")); @@ -1341,7 +1493,23 @@ void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOper << (targetAppDirPath + QLatin1String("/../plugins"))); performOperationThreaded(op); } +#else + Q_UNUSED(performedOperations); #endif +} + +void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOperations) +{ + if (m_disableWriteMaintenanceTool) { + qCDebug(QInstaller::lcInstallerInstallLog()) << "Maintenance tool writing disabled."; + return; + } + + bool gainedAdminRights = false; + if (!directoryWritable(targetDir())) { + m_core->gainAdminRights(); + gainedAdminRights = true; + } try { // 1 - check if we have a installer base replacement @@ -1377,45 +1545,56 @@ void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOper // 5.1 - this will only happen -if- we wrote out a new binary bool newBinaryWritten = false; - bool replacementExists = false; + QString mtName = maintenanceToolName(); const QString installerBaseBinary = replaceVariables(m_installerBaseBinaryUnreplaced); - if (!installerBaseBinary.isEmpty() && QFileInfo(installerBaseBinary).exists()) { + bool macOsMTBundleExtracted = false; + if (!installerBaseBinary.isEmpty() && QFileInfo::exists(installerBaseBinary)) { qCDebug(QInstaller::lcInstallerInstallLog) << "Got a replacement installer base binary:" << installerBaseBinary; - - QFile replacementBinary(installerBaseBinary); - try { - QInstaller::openForRead(&replacementBinary); - writeMaintenanceToolBinary(&replacementBinary, replacementBinary.size(), true); - qCDebug(QInstaller::lcInstallerInstallLog) << "Wrote the binary with the new replacement."; - + if (QInstaller::isInBundle(installerBaseBinary)) { + // In macOS the installerbase is a whole app bundle. We do not modify the maintenancetool name in app bundle + // so that possible signing and notarization will remain. Therefore, the actual maintenance tool name might + // differ from the one defined in the settings. newBinaryWritten = true; - replacementExists = true; - } catch (const Error &error) { - qCWarning(QInstaller::lcInstallerInstallLog) << error.message(); - } - - if (!replacementBinary.remove()) { - // Is there anything more sensible we can do with this error? I think not. It's not serious - // enough for throwing / aborting the process. - qCDebug(QInstaller::lcInstallerInstallLog) << "Cannot remove installer base binary" - << installerBaseBinary << "after updating the maintenance tool:" - << replacementBinary.errorString(); + mtName = installerBaseBinary; + macOsMTBundleExtracted = true; } else { - qCDebug(QInstaller::lcInstallerInstallLog) << "Removed installer base binary" - << installerBaseBinary << "after updating the maintenance tool."; + writeMaintenanceToolAppBundle(performedOperations); + QFile replacementBinary(installerBaseBinary); + try { + QInstaller::openForRead(&replacementBinary); + writeMaintenanceToolBinary(&replacementBinary, replacementBinary.size(), true); + qCDebug(QInstaller::lcInstallerInstallLog) << "Wrote the binary with the new replacement."; + + newBinaryWritten = true; + } catch (const Error &error) { + qCWarning(QInstaller::lcInstallerInstallLog) << error.message(); + } + + if (!replacementBinary.remove()) { + // Is there anything more sensible we can do with this error? I think not. It's not serious + // enough for throwing / aborting the process. + qCDebug(QInstaller::lcInstallerInstallLog) << "Cannot remove installer base binary" + << installerBaseBinary << "after updating the maintenance tool:" + << replacementBinary.errorString(); + } else { + qCDebug(QInstaller::lcInstallerInstallLog) << "Removed installer base binary" + << installerBaseBinary << "after updating the maintenance tool."; + } } m_installerBaseBinaryUnreplaced.clear(); - } else if (!installerBaseBinary.isEmpty() && !QFileInfo(installerBaseBinary).exists()) { + } else if (!installerBaseBinary.isEmpty() && !QFileInfo::exists(installerBaseBinary)) { qCWarning(QInstaller::lcInstallerInstallLog) << "The current maintenance tool could not be updated." << installerBaseBinary << "does not exist. Please fix the \"setInstallerBaseBinary" "(<temp_installer_base_binary_path>)\" call in your script."; + writeMaintenanceToolAppBundle(performedOperations); + } else { + writeMaintenanceToolAppBundle(performedOperations); } QFile input; BinaryLayout layout; - const QString dataFile = targetDir() + QLatin1Char('/') + m_data.settings().maintenanceToolName() - + QLatin1String(".dat"); + const QString dataFile = datFileName(); try { if (isInstaller()) { if (QFile::exists(dataFile)) { @@ -1496,14 +1675,40 @@ void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOper input.close(); if (m_core->isInstaller()) registerMaintenanceTool(); +#ifdef Q_OS_MACOS + if (newBinaryWritten) { + // Remove old alias as the name may have changed. + deleteMaintenanceToolAlias(); + const QString aliasPath = maintenanceToolAliasPath(); + if (!aliasPath.isEmpty()) { + // The new alias file is created after the maintenance too binary is renamed, + // but we need to set the value before the variables get written to disk. + m_core->setValue(QLatin1String("CreatedMaintenanceToolAlias"), aliasPath); + } + } +#endif writeMaintenanceConfigFiles(); - deferredRename(dataFile + QLatin1String(".new"), dataFile, false); + + QFile::remove(dataFile); + QFileInfo fi(mtName); + //Rename the dat file according to maintenancetool name + QFile::rename(dataFile + QLatin1String(".new"), targetDir() + QLatin1Char('/') + fi.baseName() + QLatin1String(".dat")); + + const bool restart = !statusCanceledOrFailed() && m_needsHardRestart; + qCDebug(QInstaller::lcInstallerInstallLog) << "Maintenance tool hard restart:" + << (restart ? "true." : "false."); if (newBinaryWritten) { - const bool restart = replacementExists && isUpdater() && (!statusCanceledOrFailed()) && m_needsHardRestart; - deferredRename(maintenanceToolName() + QLatin1String(".new"), maintenanceToolName(), restart); - qCDebug(QInstaller::lcInstallerInstallLog) << "Maintenance tool restart:" - << (restart ? "true." : "false."); + if (macOsMTBundleExtracted) + deferredRename(mtName, targetDir() + QDir::separator() + fi.fileName(), restart); + else if (isInstaller()) + QFile::rename(mtName + QLatin1String(".new"), mtName); + else + deferredRename(mtName + QLatin1String(".new"), mtName, restart); + QFileInfo mtFileName(mtName); + writeMaintenanceToolAlias(mtFileName.fileName()); + } else if (restart) { + SelfRestarter::setRestartOnQuit(true); } } catch (const Error &err) { setStatus(PackageManagerCore::Failure); @@ -1573,6 +1778,28 @@ void PackageManagerCorePrivate::writeOfflineBaseBinary() } } +void PackageManagerCorePrivate::writeMaintenanceToolAlias(const QString &maintenanceToolName) +{ +#ifdef Q_OS_MACOS + const QString aliasPath = maintenanceToolAliasPath(); + if (aliasPath.isEmpty()) + return; + + QString maintenanceToolBundle = QString::fromLatin1("%1/%2") + .arg(targetDir(), maintenanceToolName); + if (!maintenanceToolBundle.endsWith(QLatin1String(".app"))) + maintenanceToolBundle += QLatin1String(".app"); + + const QDir targetDir(QFileInfo(aliasPath).absolutePath()); + if (!targetDir.exists()) + targetDir.mkpath(targetDir.absolutePath()); + + mkalias(maintenanceToolBundle, aliasPath); +#else + Q_UNUSED(maintenanceToolName) +#endif +} + QString PackageManagerCorePrivate::registerPath() { #ifdef Q_OS_WIN @@ -1657,7 +1884,7 @@ bool PackageManagerCorePrivate::runInstaller() throw Error(tr("It is not possible to install from network location")); } - if (!adminRightsGained) { + if (!m_core->hasAdminRights()) { foreach (Component *component, componentsToInstall) { if (component->value(scRequiresAdminRights, scFalse) == scFalse) continue; @@ -1690,8 +1917,8 @@ bool PackageManagerCorePrivate::runInstaller() + (PackageManagerCore::createLocalRepositoryFromBinary() ? 1 : 0); double progressOperationSize = componentsInstallPartProgressSize / progressOperationCount; - foreach (Component *component, componentsToInstall) - installComponent(component, progressOperationSize, adminRightsGained); + // Now install the requested components + unpackAndInstallComponents(componentsToInstall, progressOperationSize); if (m_core->isOfflineOnly() && PackageManagerCore::createLocalRepositoryFromBinary()) { emit m_core->titleMessageChanged(tr("Creating local repository")); @@ -1750,7 +1977,8 @@ bool PackageManagerCorePrivate::runInstaller() if (progress < 100) ProgressCoordinator::instance()->addManualPercentagePoints(100 - progress); - ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("\nInstallation finished!")); + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Installation finished!")); if (adminRightsGained) m_core->dropAdminRights(); @@ -1768,7 +1996,9 @@ bool PackageManagerCorePrivate::runInstaller() m_core->rollBackInstallation(); - ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("\nInstallation aborted!")); + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Installation aborted!")); + if (adminRightsGained) m_core->dropAdminRights(); emit installationFinished(); @@ -1846,7 +2076,7 @@ bool PackageManagerCorePrivate::runPackageUpdater() // There is a replacement, but the replacement is not scheduled for update, keep it as well. if (m_componentsToReplaceUpdaterMode.contains(name) - && !m_componentsToReplaceUpdaterMode.value(name).first->updateRequested()) { + && !m_installerCalculator->resolvedComponents().contains(m_componentsToReplaceUpdaterMode.value(name).first)) { nonRevertedOperations.append(operation); continue; } @@ -1886,7 +2116,7 @@ bool PackageManagerCorePrivate::runPackageUpdater() } // we did not request admin rights till we found out that a component/ undo needs admin rights - if (updateAdminRights && !adminRightsGained) { + if (updateAdminRights && !m_core->hasAdminRights()) { m_core->gainAdminRights(); m_core->dropAdminRights(); } @@ -1907,15 +2137,15 @@ bool PackageManagerCorePrivate::runPackageUpdater() if (undoOperations.count() > 0) { ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("Removing deselected components...")); - runUndoOperations(undoOperations, undoOperationProgressSize, adminRightsGained, true); + runUndoOperations(undoOperations, undoOperationProgressSize, true); } m_performedOperationsOld = nonRevertedOperations; // these are all operations left: those not reverted const double progressOperationCount = countProgressOperations(componentsToInstall); const double progressOperationSize = componentsInstallPartProgressSize / progressOperationCount; - foreach (Component *component, componentsToInstall) - installComponent(component, progressOperationSize, adminRightsGained); + // Now install the requested new components + unpackAndInstallComponents(componentsToInstall, progressOperationSize); emit m_core->titleMessageChanged(tr("Creating Maintenance Tool")); @@ -1927,7 +2157,8 @@ bool PackageManagerCorePrivate::runPackageUpdater() // usually this should be only the reserved one from the beginning if (progress < 100) ProgressCoordinator::instance()->addManualPercentagePoints(100 - progress); - ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("\nUpdate finished!")); + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Update finished!")); if (adminRightsGained) m_core->dropAdminRights(); @@ -1947,7 +2178,9 @@ bool PackageManagerCorePrivate::runPackageUpdater() m_core->rollBackInstallation(); - ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("\nUpdate aborted!")); + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Update aborted!")); + if (adminRightsGained) m_core->dropAdminRights(); emit installationFinished(); @@ -1981,7 +2214,7 @@ bool PackageManagerCorePrivate::runUninstaller() } // We did not yet request elevated permissions but they are required. - if (updateAdminRights && !adminRightsGained) { + if (updateAdminRights && !m_core->hasAdminRights()) { m_core->gainAdminRights(); m_core->dropAdminRights(); } @@ -1989,15 +2222,16 @@ bool PackageManagerCorePrivate::runUninstaller() const int uninstallOperationCount = countProgressOperations(undoOperations); const double undoOperationProgressSize = double(1) / double(uninstallOperationCount); - runUndoOperations(undoOperations, undoOperationProgressSize, adminRightsGained, false); + runUndoOperations(undoOperations, undoOperationProgressSize, false); // No operation delete here, as all old undo operations are deleted in the destructor. deleteMaintenanceTool(); // this will also delete the TargetDir on Windows + deleteMaintenanceToolAlias(); // If not on Windows, we need to remove TargetDir manually. #ifndef Q_OS_WIN if (QVariant(m_core->value(scRemoveTargetDir)).toBool() && !targetDir().isEmpty()) { - if (updateAdminRights && !adminRightsGained) + if (updateAdminRights && !m_core->hasAdminRights()) adminRightsGained = m_core->gainAdminRights(); removeDirectoryThreaded(targetDir(), true); qCDebug(QInstaller::lcInstallerInstallLog) << "Complete uninstallation was chosen."; @@ -2073,7 +2307,7 @@ bool PackageManagerCorePrivate::runOfflineGenerator() m_core->downloadNeededArchives(double(1)); const QString installerBaseReplacement = replaceVariables(m_offlineBaseBinaryUnreplaced); - if (!installerBaseReplacement.isEmpty() && QFileInfo(installerBaseReplacement).exists()) { + if (!installerBaseReplacement.isEmpty() && QFileInfo::exists(installerBaseReplacement)) { qCDebug(QInstaller::lcInstallerInstallLog) << "Got a replacement installer base binary:" << offlineBinaryTempName; @@ -2158,10 +2392,151 @@ bool PackageManagerCorePrivate::runOfflineGenerator() return success; } -void PackageManagerCorePrivate::installComponent(Component *component, double progressOperationSize, - bool adminRightsGained) +void PackageManagerCorePrivate::unpackComponents(const QList<Component *> &components, + double progressOperationSize) { - const OperationList operations = component->operations(); + OperationList unpackOperations; + bool becameAdmin = false; + + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Preparing to unpack components...")); + + // 1. Collect operations + quint64 totalOperationsSizeHint = 0; + for (auto *component : components) { + const OperationList operations = component->operations(Operation::Unpack); + if (!component->operationsCreatedSuccessfully()) + m_core->setCanceled(); + + for (auto &op : operations) { + if (statusCanceledOrFailed()) + throw Error(tr("Installation canceled by user")); + + unpackOperations.append(op); + totalOperationsSizeHint += op->sizeHint(); + + // There's currently no way to control this on a per-operation basis, so + // any op requesting execution as admin means all extracts are done as admin. + if (!m_core->hasAdminRights() && op->value(QLatin1String("admin")).toBool()) + becameAdmin = m_core->gainAdminRights(); + } + } + + // 2. Calculate proportional progress sizes + const double totalOperationsSize = progressOperationSize * unpackOperations.size(); + for (auto *op : unpackOperations) { + const double ratio = static_cast<double>(op->sizeHint()) / totalOperationsSizeHint; + const double proportionalProgressOperationSize = totalOperationsSize * ratio; + + connectOperationToInstaller(op, proportionalProgressOperationSize); + connectOperationCallMethodRequest(op); + } + + // 3. Backup operations + ConcurrentOperationRunner runner(&unpackOperations, Operation::Backup); + runner.setMaxThreadCount(m_core->maxConcurrentOperations()); + + connect(m_core, &PackageManagerCore::installationInterrupted, + &runner, &ConcurrentOperationRunner::cancel); + + connect(&runner, &ConcurrentOperationRunner::progressChanged, [](const int completed, const int total) { + const QString statusText = tr("%1 of %2 operations completed.") + .arg(QString::number(completed), QString::number(total)); + ProgressCoordinator::instance()->emitAdditionalProgressStatus(statusText); + }); + connect(&runner, &ConcurrentOperationRunner::finished, [] { + // Clear the status text to not cause confusion when installations begin. + ProgressCoordinator::instance()->emitAdditionalProgressStatus(QLatin1String("")); + }); + + const QHash<Operation *, bool> backupResults = runner.run(); + const OperationList backupOperations = backupResults.keys(); + + for (auto &operation : backupOperations) { + if (m_core->status() == PackageManagerCore::Canceled) + break; // User canceled, no need to print warnings + + if (!backupResults.value(operation) || operation->error() != Operation::NoError) { + // For Extract, backup stops only on read errors. That means the perform step will + // also fail later on, which handles the user selection on what to do with the error. + qCWarning(QInstaller::lcInstallerInstallLog) << QString::fromLatin1("Backup of operation " + "\"%1\" with arguments \"%2\" failed: %3").arg(operation->name(), operation->arguments() + .join(QLatin1String("; ")), operation->errorString()); + continue; + } + // Backup may request performing operation as admin + if (!m_core->hasAdminRights() && operation->value(QLatin1String("admin")).toBool()) + becameAdmin = m_core->gainAdminRights(); + } + + // TODO: Do we need to rollback backups too? For Extract op this works without, + // as the backup files are not used in Undo step. + if (statusCanceledOrFailed()) + throw Error(tr("Installation canceled by user")); + + // 4. Perform operations + std::sort(unpackOperations.begin(), unpackOperations.end(), [](Operation *lhs, Operation *rhs) { + // We want to run the longest taking operations first + return lhs->sizeHint() > rhs->sizeHint(); + }); + + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Unpacking components...")); + + runner.setType(Operation::Perform); + const QHash<Operation *, bool> results = runner.run(); + const OperationList performedOperations = results.keys(); + + QString error; + for (auto &operation : performedOperations) { + const QString component = operation->value(QLatin1String("component")).toString(); + + bool ignoreError = false; + bool ok = results.value(operation); + + while (!ok && !ignoreError && m_core->status() != PackageManagerCore::Canceled) { + qCDebug(QInstaller::lcInstallerInstallLog) << QString::fromLatin1("Operation \"%1\" with arguments " + "\"%2\" failed: %3").arg(operation->name(), operation->arguments() + .join(QLatin1String("; ")), operation->errorString()); + + const QMessageBox::StandardButton button = + MessageBoxHandler::warning(MessageBoxHandler::currentBestSuitParent(), + QLatin1String("installationErrorWithCancel"), tr("Installer Error"), + tr("Error during installation process (%1):\n%2").arg(component, operation->errorString()), + QMessageBox::Retry | QMessageBox::Ignore | QMessageBox::Cancel, QMessageBox::Cancel); + + if (button == QMessageBox::Retry) + ok = performOperationThreaded(operation); + else if (button == QMessageBox::Ignore) + ignoreError = true; + else if (button == QMessageBox::Cancel) + m_core->interrupt(); + } + + if (ok || operation->error() > Operation::InvalidArguments) { + // Remember that the operation was performed, that allows us to undo it + // if this operation failed but still needs an undo call to cleanup. + addPerformed(operation); + } + + // Catch the error message from first failure, but throw only after all + // operations requiring undo step are marked as performed. + if (!ok && !ignoreError && error.isEmpty()) + error = operation->errorString(); + } + + if (becameAdmin) + m_core->dropAdminRights(); + + if (!error.isEmpty()) + throw Error(error); + + ProgressCoordinator::instance()->emitDetailTextChanged(tr("Done")); +} + +void PackageManagerCorePrivate::installComponent(Component *component, double progressOperationSize) +{ + OperationList operations = component->operations(Operation::Install); if (!component->operationsCreatedSuccessfully()) m_core->setCanceled(); @@ -2169,8 +2544,8 @@ void PackageManagerCorePrivate::installComponent(Component *component, double pr // show only components which do something, MinimumProgress is only for progress calculation safeness bool showDetailsLog = false; if (opCount > 1 || (opCount == 1 && operations.at(0)->name() != QLatin1String("MinimumProgress"))) { - ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("\nInstalling component %1") - .arg(component->displayName())); + ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(QLatin1Char('\n') + + tr("Installing component %1").arg(component->displayName())); showDetailsLog = true; } @@ -2180,7 +2555,7 @@ void PackageManagerCorePrivate::installComponent(Component *component, double pr // maybe this operations wants us to be admin... bool becameAdmin = false; - if (!adminRightsGained && operation->value(QLatin1String("admin")).toBool()) { + if (!m_core->hasAdminRights() && operation->value(QLatin1String("admin")).toBool()) { becameAdmin = m_core->gainAdminRights(); qCDebug(QInstaller::lcInstallerInstallLog) << operation->name() << "as admin:" << becameAdmin; } @@ -2223,11 +2598,13 @@ void PackageManagerCorePrivate::installComponent(Component *component, double pr if (!ok && !ignoreError) throw Error(operation->errorString()); + } - if (((component->value(scEssential, scFalse) == scTrue) || (component->value(scForcedUpdate, scFalse) == scTrue)) - && !m_core->isCommandLineInstance()) { + if (!m_core->isCommandLineInstance()) { + if ((component->value(scEssential, scFalse) == scTrue) && !isInstaller()) + m_needsHardRestart = true; + else if ((component->value(scForcedUpdate, scFalse) == scTrue) && isUpdater()) m_needsHardRestart = true; - } } registerPathsForUninstallation(component->pathsForUninstallation(), component->name()); @@ -2245,8 +2622,10 @@ void PackageManagerCorePrivate::installComponent(Component *component, double pr m_localPackageHub->addPackage(component->name(), component->value(scVersion), component->value(scDisplayName), - component->value(scTreeName), + QPair<QString, bool>(component->value(scTreeName), + component->treeNameMoveChildren()), component->value(scDescription), + component->value(scSortingPriority).toInt(), component->dependencies(), component->autoDependencies(), component->forcedInstallation(), @@ -2265,23 +2644,67 @@ void PackageManagerCorePrivate::installComponent(Component *component, double pr ProgressCoordinator::instance()->emitDetailTextChanged(tr("Done")); } -bool PackageManagerCorePrivate::runningProcessesFound() +PackageManagerCore::Status PackageManagerCorePrivate::fetchComponentsAndInstall(const QStringList& components) { - //Check if there are processes running in the install - QStringList excludeFiles = m_allowedRunningProcesses; - excludeFiles.append(maintenanceToolName()); + // init default model before fetching remote packages tree + ComponentModel *model = m_core->defaultComponentModel(); + Q_UNUSED(model); - const QString performModeWarning = m_completeUninstall - ? QLatin1String("Unable to remove components.") - : QLatin1String("Unable to update components."); + bool fallbackReposFetched = false; + auto fetchComponents = [&]() { + bool packagesFound = m_core->fetchPackagesWithFallbackRepositories(components, fallbackReposFetched); - QStringList runningProcesses = runningInstallerProcesses(excludeFiles); - if (!runningProcesses.isEmpty()) { - qCWarning(QInstaller::lcInstallerInstallLog).noquote().nospace() << performModeWarning - << " Please stop these processes: " << runningProcesses << " and try again."; + if (!packagesFound) { + qCDebug(QInstaller::lcInstallerInstallLog).noquote().nospace() + << "No components available with the current selection."; + setStatus(PackageManagerCore::Canceled); + return false; + } + QString errorMessage; + bool unstableAliasFound = false; + if (m_core->checkComponentsForInstallation(components, errorMessage, unstableAliasFound, fallbackReposFetched)) { + if (!errorMessage.isEmpty()) + qCDebug(QInstaller::lcInstallerInstallLog).noquote().nospace() << errorMessage; + if (calculateComponentsAndRun()) { + if (m_core->isOfflineGenerator()) + qCDebug(QInstaller::lcInstallerInstallLog) << "Created installer to:" << offlineBinaryName(); + else + qCDebug(QInstaller::lcInstallerInstallLog) << "Components installed successfully"; + } + } else { + // We found unstable alias and all repos were not fetched. Alias might have dependency to component + // which exists in non-default repository. Fetch all repositories now. + if (unstableAliasFound && !fallbackReposFetched) { + return false; + } else { + for (const QString &possibleAliasName : components) { + if (ComponentAlias *alias = m_core->aliasByName(possibleAliasName)) { + if (alias->componentErrorMessage().isEmpty()) + continue; + qCWarning(QInstaller::lcInstallerInstallLog).noquote().nospace() << alias->componentErrorMessage(); + } + } + qCDebug(QInstaller::lcInstallerInstallLog).noquote().nospace() << errorMessage + << "No components available with the current selection."; + } + } return true; + }; + + if (!fetchComponents() && !fallbackReposFetched) { + fallbackReposFetched = true; + setStatus(PackageManagerCore::Running); + 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(); + } + enableAllCategories(); + fetchComponents(); } - return false; + + return m_core->status(); } void PackageManagerCorePrivate::setComponentSelection(const QString &id, Qt::CheckState state) @@ -2302,6 +2725,14 @@ void PackageManagerCorePrivate::setComponentSelection(const QString &id, Qt::Che void PackageManagerCorePrivate::deleteMaintenanceTool() { + QDir resourcePath(QFileInfo(maintenanceToolName()).dir()); + resourcePath.remove(QLatin1String("installer.dat")); + QDir installDir(targetDir()); + installDir.remove(m_data.settings().maintenanceToolName() + QLatin1String(".dat")); + installDir.remove(QLatin1String("network.xml")); + installDir.remove(m_data.settings().maintenanceToolIniFile()); + QInstaller::VerboseWriter::instance()->setFileName(QString()); + installDir.remove(m_core->value(QLatin1String("LogFileName"), QLatin1String("InstallationLog.txt"))); #ifdef Q_OS_WIN // Since Windows does not support that the maintenance tool deletes itself we have to go with a rather dirty // hack. What we do is to create a batchfile that will try to remove the maintenance tool once per second. Then @@ -2314,6 +2745,7 @@ void PackageManagerCorePrivate::deleteMaintenanceTool() if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) throw Error(tr("Cannot prepare removal")); + const bool removeTargetDir = QVariant(m_core->value(scRemoveTargetDir)).toBool(); QTextStream batch(&f); batch << "Set fso = WScript.CreateObject(\"Scripting.FileSystemObject\")\n"; batch << "file = WScript.Arguments.Item(0)\n"; @@ -2325,10 +2757,12 @@ void PackageManagerCorePrivate::deleteMaintenanceTool() batch << " fso.DeleteFile(file)\n"; batch << " WScript.Sleep(1000)\n"; batch << "wend\n"; -// batch << "if folder.SubFolders.Count = 0 and folder.Files.Count = 0 then\n"; + if (!removeTargetDir) + batch << "if folder.SubFolders.Count = 0 and folder.Files.Count = 0 then\n"; batch << " Set folder = Nothing\n"; batch << " fso.DeleteFolder folderpath, true\n"; -// batch << "end if\n"; + if (!removeTargetDir) + batch << "end if\n"; batch << "fso.DeleteFile(WScript.ScriptFullName)\n"; f.close(); @@ -2336,11 +2770,7 @@ void PackageManagerCorePrivate::deleteMaintenanceTool() QStringList arguments; arguments << QLatin1String("//Nologo") << batchfile; // execute the batchfile arguments << QDir::toNativeSeparators(QFileInfo(installerBinaryPath()).absoluteFilePath()); - if (!m_performedOperationsOld.isEmpty()) { - const Operation *const op = m_performedOperationsOld.first(); - if (op->name() == QLatin1String("Mkdir")) // the target directory name - arguments << QDir::toNativeSeparators(QFileInfo(op->arguments().first()).absoluteFilePath()); - } + arguments << targetDir(); if (!QProcessWrapper::startDetached(QLatin1String("cscript"), arguments, QDir::rootPath())) throw Error(tr("Cannot start removal")); @@ -2364,10 +2794,27 @@ void PackageManagerCorePrivate::deleteMaintenanceTool() } } +void PackageManagerCorePrivate::deleteMaintenanceToolAlias() +{ +#ifdef Q_OS_MACOS + const QString maintenanceToolAlias = m_core->value(QLatin1String("CreatedMaintenanceToolAlias")); + QFile aliasFile(maintenanceToolAlias); + if (!maintenanceToolAlias.isEmpty() && !aliasFile.remove()) { + // Not fatal + qWarning(lcInstallerInstallLog) << "Cannot remove alias file" + << maintenanceToolAlias << "for maintenance tool:" << aliasFile.errorString(); + } +#endif +} + void PackageManagerCorePrivate::registerMaintenanceTool() { #ifdef Q_OS_WIN - QSettingsWrapper settings(registerPath(), QSettingsWrapper::NativeFormat); + auto quoted = [](const QString &s) { + return QString::fromLatin1("\"%1\"").arg(s); + }; + + QSettingsWrapper settings(registerPath(), QSettings::NativeFormat); settings.setValue(scDisplayName, m_data.value(QLatin1String("ProductName"))); settings.setValue(QLatin1String("DisplayVersion"), m_data.value(QLatin1String("ProductVersion"))); const QString maintenanceTool = QDir::toNativeSeparators(maintenanceToolName()); @@ -2377,9 +2824,12 @@ void PackageManagerCorePrivate::registerMaintenanceTool() settings.setValue(QLatin1String("Comments"), m_data.value(scTitle)); settings.setValue(QLatin1String("InstallDate"), QDateTime::currentDateTime().toString()); settings.setValue(QLatin1String("InstallLocation"), QDir::toNativeSeparators(targetDir())); - settings.setValue(QLatin1String("UninstallString"), maintenanceTool); - settings.setValue(QLatin1String("ModifyPath"), QString(maintenanceTool - + QLatin1String(" --manage-packages"))); + settings.setValue(QLatin1String("UninstallString"), QString(quoted(maintenanceTool) + + QLatin1String(" --") + CommandLineOptions::scStartUninstallerLong)); + if (!isOfflineOnly()) { + settings.setValue(QLatin1String("ModifyPath"), QString(quoted(maintenanceTool) + + QLatin1String(" --") + CommandLineOptions::scStartPackageManagerLong)); + } // required disk space of the installed components quint64 estimatedSizeKB = m_core->requiredDiskSpace() / 1024; // add required space for the maintenance tool @@ -2411,21 +2861,24 @@ void PackageManagerCorePrivate::registerMaintenanceTool() void PackageManagerCorePrivate::unregisterMaintenanceTool() { #ifdef Q_OS_WIN - QSettingsWrapper settings(registerPath(), QSettingsWrapper::NativeFormat); + QSettingsWrapper settings(registerPath(), QSettings::NativeFormat); settings.remove(QString()); #endif } -void PackageManagerCorePrivate::runUndoOperations(const OperationList &undoOperations, double progressSize, - bool adminRightsGained, bool deleteOperation) +void PackageManagerCorePrivate::runUndoOperations(const OperationList &undoOperations, + double progressSize, bool deleteOperation) { try { + const int operationsCount = undoOperations.size(); + int rolledBackOperations = 0; + foreach (Operation *undoOperation, undoOperations) { if (statusCanceledOrFailed()) throw Error(tr("Installation canceled by user")); bool becameAdmin = false; - if (!adminRightsGained && undoOperation->value(QLatin1String("admin")).toBool()) + if (!m_core->hasAdminRights() && undoOperation->value(QLatin1String("admin")).toBool()) becameAdmin = m_core->gainAdminRights(); connectOperationToInstaller(undoOperation, progressSize); @@ -2458,6 +2911,10 @@ void PackageManagerCorePrivate::runUndoOperations(const OperationList &undoOpera } } + ++rolledBackOperations; + ProgressCoordinator::instance()->emitAdditionalProgressStatus(tr("%1 of %2 operations rolled back.") + .arg(QString::number(rolledBackOperations), QString::number(operationsCount))); + if (becameAdmin) m_core->dropAdminRights(); @@ -2472,6 +2929,7 @@ void PackageManagerCorePrivate::runUndoOperations(const OperationList &undoOpera throw Error(tr("Unknown error")); } m_localPackageHub->writeToDisk(); + ProgressCoordinator::instance()->emitAdditionalProgressStatus(tr("Rollbacks complete.")); } PackagesList PackageManagerCorePrivate::remotePackages() @@ -2503,12 +2961,12 @@ PackagesList PackageManagerCorePrivate::remotePackages() the application is running in installer mode or the local components file could not be parsed, the hash is empty. */ -LocalPackagesHash PackageManagerCorePrivate::localInstalledPackages() +LocalPackagesMap PackageManagerCorePrivate::localInstalledPackages() { if (isInstaller()) - return LocalPackagesHash(); + return LocalPackagesMap(); + - LocalPackagesHash installedPackages; if (m_localPackageHub->error() != LocalPackageHub::NoError) { if (m_localPackageHub->fileName().isEmpty()) m_localPackageHub->setFileName(componentsXmlPath()); @@ -2525,14 +2983,26 @@ LocalPackagesHash PackageManagerCorePrivate::localInstalledPackages() setStatus(PackageManagerCore::Failure, tr("Failure to read packages from %1.") .arg(componentsXmlPath())); } + return m_localPackageHub->localPackages(); +} - foreach (const LocalPackage &package, m_localPackageHub->packageInfos()) { - if (statusCanceledOrFailed()) - break; - installedPackages.insert(package.name, package); +QList<ComponentAlias *> PackageManagerCorePrivate::componentAliases() +{ + if (m_aliases && m_aliasFinder) + return m_aliasFinder->aliases(); + + m_aliases = false; + delete m_aliasFinder; + + m_aliasFinder = new AliasFinder(m_core); + m_aliasFinder->setAliasSources(m_aliasSources); + if (!m_aliasFinder->run()) { + qCDebug(lcDeveloperBuild) << "No component aliases found." << Qt::endl; + return QList<ComponentAlias *>(); } - return installedPackages; + m_aliases = true; + return m_aliasFinder->aliases(); } bool PackageManagerCorePrivate::fetchMetaInformationFromRepositories(DownloadType type) @@ -2565,12 +3035,12 @@ bool PackageManagerCorePrivate::fetchMetaInformationFromRepositories(DownloadTyp return m_repoFetched; } -bool PackageManagerCorePrivate::addUpdateResourcesFromRepositories(bool parseChecksum, bool compressedRepository) +bool PackageManagerCorePrivate::addUpdateResourcesFromRepositories(bool compressedRepository) { if (!compressedRepository && m_updateSourcesAdded) return m_updateSourcesAdded; - const QList<Metadata> metadata = m_metadataJob.metadata(); + const QList<Metadata *> metadata = m_metadataJob.metadata(); if (metadata.isEmpty()) { m_updateSourcesAdded = true; return m_updateSourcesAdded; @@ -2583,53 +3053,25 @@ bool PackageManagerCorePrivate::addUpdateResourcesFromRepositories(bool parseChe m_updates = false; m_updateSourcesAdded = false; if (isInstaller()) - m_packageSources.insert(PackageSource(QUrl(QLatin1String("resource://metadata/")), 0)); + m_packageSources.insert(PackageSource(QUrl(QLatin1String("resource://metadata/")), 1)); } - foreach (const Metadata &data, metadata) { - if (compressedRepository && !data.repository.isCompressed()) { + foreach (const Metadata *data, metadata) { + if (compressedRepository && !data->repository().isCompressed()) { continue; } if (statusCanceledOrFailed()) return false; - if (data.directory.isEmpty()) + if (data->path().isEmpty()) continue; - if (parseChecksum) { - const QString updatesXmlPath = data.directory + QLatin1String("/Updates.xml"); - QFile updatesFile(updatesXmlPath); - try { - QInstaller::openForRead(&updatesFile); - } catch(const Error &e) { - qCWarning(QInstaller::lcInstallerInstallLog) << "Error opening Updates.xml:" - << e.message(); - setStatus(PackageManagerCore::Failure, tr("Cannot add temporary update source information.")); - return false; - } - - int line = 0; - int column = 0; - QString error; - QDomDocument doc; - if (!doc.setContent(&updatesFile, &error, &line, &column)) { - qCWarning(QInstaller::lcInstallerInstallLog).nospace() << "Parse error in file " - << updatesFile.fileName() << ": " << error << " at line " << line - << " col " << column; - setStatus(PackageManagerCore::Failure, tr("Cannot add temporary update source information.")); - return false; - } - - const QDomNode checksum = doc.documentElement().firstChildElement(QLatin1String("Checksum")); - if (!checksum.isNull()) - m_core->setTestChecksum(checksum.toElement().text().toLower() == scTrue); - } - if (data.repository.isCompressed()) - m_compressedPackageSources.insert(PackageSource(QUrl::fromLocalFile(data.directory), 2)); + if (data->repository().isCompressed()) + m_compressedPackageSources.insert(PackageSource(QUrl::fromLocalFile(data->path()), 2, data->repository().postLoadComponentScript())); else - m_packageSources.insert(PackageSource(QUrl::fromLocalFile(data.directory), 1)); + m_packageSources.insert(PackageSource(QUrl::fromLocalFile(data->path()), 0, data->repository().postLoadComponentScript())); - ProductKeyCheck::instance()->addPackagesFromXml(data.directory + QLatin1String("/Updates.xml")); + ProductKeyCheck::instance()->addPackagesFromXml(data->path() + QLatin1String("/Updates.xml")); } if ((compressedRepository && m_compressedPackageSources.count() == 0 ) || (!compressedRepository && m_packageSources.count() == 0)) { @@ -2655,7 +3097,6 @@ void PackageManagerCorePrivate::restoreCheckState() } m_coreCheckedHash.clear(); - m_componentsToInstallCalculated = false; } void PackageManagerCorePrivate::storeCheckState() @@ -2668,6 +3109,138 @@ void PackageManagerCorePrivate::storeCheckState() m_coreCheckedHash.insert(component, component->checkState()); } +void PackageManagerCorePrivate::updateComponentInstallActions() +{ + for (Component *component : m_core->components(PackageManagerCore::ComponentType::All)) { + component->setInstallAction(component->isInstalled() + ? ComponentModelHelper::KeepInstalled + : ComponentModelHelper::KeepUninstalled); + } + for (Component *component : uninstallerCalculator()->resolvedComponents()) + component->setInstallAction(ComponentModelHelper::Uninstall); + for (Component *component : installerCalculator()->resolvedComponents()) + component->setInstallAction(ComponentModelHelper::Install); +} + +bool PackageManagerCorePrivate::enableAllCategories() +{ + QSet<RepositoryCategory> repoCategories = m_data.settings().repositoryCategories(); + bool additionalRepositoriesEnabled = false; + for (const auto &category : repoCategories) { + if (!category.isEnabled()) { + additionalRepositoriesEnabled = true; + enableRepositoryCategory(category, true); + } + } + return additionalRepositoriesEnabled; +} + +void PackageManagerCorePrivate::enableRepositoryCategory(const RepositoryCategory &repoCategory, const bool enable) +{ + RepositoryCategory replacement = repoCategory; + replacement.setEnabled(enable); + QSet<RepositoryCategory> tmpRepoCategories = m_data.settings().repositoryCategories(); + if (tmpRepoCategories.contains(repoCategory)) { + tmpRepoCategories.remove(repoCategory); + tmpRepoCategories.insert(replacement); + m_data.settings().addRepositoryCategories(tmpRepoCategories); + } +} + +bool PackageManagerCorePrivate::installablePackagesFound(const QStringList& components) +{ + if (components.isEmpty()) + return true; + + PackagesList remotes = remotePackages(); + + auto componentsNotFoundForInstall = QtConcurrent::blockingFiltered( + components, + [remotes](const QString& installerPackage) { + return filterMissingPackagesToInstall(installerPackage, remotes); + } + ); + + if (componentsNotFoundForInstall.count() > 0) { + QList<ComponentAlias *> aliasList = componentAliases(); + auto aliasesNotFoundForInstall = QtConcurrent::blockingFiltered( + componentsNotFoundForInstall, + [aliasList](const QString& installerPackage) { + return filterMissingAliasesToInstall(installerPackage, aliasList); + } + ); + + if (aliasesNotFoundForInstall.count() > 0) { + qCDebug(QInstaller::lcInstallerInstallLog).noquote().nospace() << "Cannot select " << aliasesNotFoundForInstall.join(QLatin1String(", ")) << ". Component(s) not found."; + setStatus(PackageManagerCore::NoPackagesFound); + return false; + } + } + return true; +} + +void PackageManagerCorePrivate::deferredRename(const QString &oldName, const QString &newName, bool restart) +{ + +#ifdef Q_OS_WINDOWS + const QString currentExecutable = QCoreApplication::applicationFilePath(); + QString tmpExecutable = generateTemporaryFileName(currentExecutable); + QFile::rename(currentExecutable, tmpExecutable); + QFile::rename(oldName, newName); + + QStringList arguments; + if (restart) { + // Restart with same command line arguments as first executable + arguments = QCoreApplication::arguments(); + arguments.removeFirst(); // Remove program name + arguments.prepend(tmpExecutable); + arguments.prepend(QLatin1String("--") + + CommandLineOptions::scCleanupUpdate); + } else { + arguments.append(QLatin1String("--") + + CommandLineOptions::scCleanupUpdateOnly); + arguments.append(tmpExecutable); + } + QProcessWrapper::startDetached2(newName, arguments); +#elif defined Q_OS_MACOS + // In macos oldName is the name of the maintenancetool we got from repository + // It might be extracted to a folder to avoid overlapping with running maintenancetool + // Here, ditto renames it to newName (and possibly moves from the subfolder). + if (oldName != newName) { + //1. Rename/move maintenancetool + QProcessWrapper process; + process.start(QLatin1String("ditto"), QStringList() << oldName << newName); + if (!process.waitForFinished()) { + qCDebug(QInstaller::lcInstallerInstallLog) << "Failed to rename maintenancetool from :" << oldName << " to "<<newName; + } + //2. Remove subfolder + QDir subDirectory(oldName); + subDirectory.cdUp(); + QString subDirectoryPath = QDir::cleanPath(subDirectory.absolutePath()); + QString targetDirectoryPath = QDir::cleanPath(targetDir()); + + //Make sure there is subdirectory in the targetdir so we don't delete the installation + if (subDirectoryPath.startsWith(targetDirectoryPath) && subDirectoryPath != targetDirectoryPath) + subDirectory.removeRecursively(); + } + + //3. If new maintenancetool name differs from original, remove the original maintenance tool + if (!isInstaller()) { + QString currentAppBundlePath = getAppBundlePath(); + if (currentAppBundlePath != newName) { + QDir oldBundlePath(currentAppBundlePath); + oldBundlePath.removeRecursively(); + } + } + SelfRestarter::setRestartOnQuit(restart); + +#elif defined Q_OS_LINUX + QFile::remove(newName); + QFile::rename(oldName, newName); + SelfRestarter::setRestartOnQuit(restart); +#endif +} + void PackageManagerCorePrivate::connectOperationCallMethodRequest(Operation *const operation) { QObject *const operationObject = dynamic_cast<QObject *> (operation); @@ -2718,6 +3291,34 @@ void PackageManagerCorePrivate::handleMethodInvocationRequest(const QString &inv QMetaObject::invokeMethod(obj, qPrintable(invokableMethodName)); } +/* + Adds the \a path for deletetion. Unlike files for delayed deletion, which are deleted + on the start of next installer run, these paths are deleted on exit. +*/ +void PackageManagerCorePrivate::addPathForDeletion(const QString &path) +{ + m_tmpPathDeleter.add(path); +} + +void PackageManagerCorePrivate::unpackAndInstallComponents(const QList<Component *> &components, + const double progressOperationSize) +{ + // Perform extract operations + unpackComponents(components, progressOperationSize); + + // Perform rest of the operations and mark component as installed + const int componentsToInstallCount = components.size(); + int installedComponents = 0; + foreach (Component *component, components) { + installComponent(component, progressOperationSize); + + ++installedComponents; + ProgressCoordinator::instance()->emitAdditionalProgressStatus(tr("%1 of %2 components installed.") + .arg(QString::number(installedComponents), QString::number(componentsToInstallCount))); + } + ProgressCoordinator::instance()->emitAdditionalProgressStatus(tr("All components installed.")); +} + void PackageManagerCorePrivate::processFilesForDelayedDeletion() { if (m_filesForDelayedDeletion.isEmpty()) @@ -2735,36 +3336,24 @@ void PackageManagerCorePrivate::processFilesForDelayedDeletion() } } -void PackageManagerCorePrivate::findExecutablesRecursive(const QString &path, const QStringList &excludeFiles, QStringList *result) -{ - QDirIterator it(path, QDir::NoDotAndDotDot | QDir::Executable | QDir::Files | QDir::System, QDirIterator::Subdirectories ); - - while (it.hasNext()) - result->append(QDir::toNativeSeparators(it.next().toLower())); - - foreach (const QString &process, excludeFiles) - result->removeAll(QDir::toNativeSeparators(process.toLower())); -} - -QStringList PackageManagerCorePrivate::runningInstallerProcesses(const QStringList &excludeFiles) -{ - QStringList resultFiles; - findExecutablesRecursive(QCoreApplication::applicationDirPath(), excludeFiles, &resultFiles); - return checkRunningProcessesFromList(resultFiles); -} - bool PackageManagerCorePrivate::calculateComponentsAndRun() { - QString htmlOutput; - bool componentsOk = m_core->calculateComponents(&htmlOutput); + bool componentsOk = m_core->recalculateAllComponents(); + if (statusCanceledOrFailed()) { qCDebug(QInstaller::lcInstallerInstallLog) << "Installation canceled."; } else if (componentsOk && acceptLicenseAgreements()) { - qCDebug(QInstaller::lcInstallerInstallLog).noquote() << htmlToString(htmlOutput); + try { + loadComponentScripts(installerCalculator()->resolvedComponents(), true); + } catch (const Error &error) { + qCWarning(QInstaller::lcInstallerInstallLog) << error.message(); + return false; + } + qCDebug(QInstaller::lcInstallerInstallLog).noquote() + << htmlToString(m_core->componentResolveReasons()); - QString spaceInfo; - const bool spaceOk = m_core->checkAvailableSpace(spaceInfo); - qCDebug(QInstaller::lcInstallerInstallLog) << spaceInfo; + const bool spaceOk = m_core->checkAvailableSpace(); + qCDebug(QInstaller::lcInstallerInstallLog) << m_core->availableSpaceMessage(); if (!spaceOk || !(m_autoConfirmCommand || askUserConfirmCommand())) { qCDebug(QInstaller::lcInstallerInstallLog) << "Installation aborted."; @@ -2791,6 +3380,13 @@ bool PackageManagerCorePrivate::acceptLicenseAgreements() const m_core->addLicenseItem(component->licenses()); } + const QString acceptanceText = ProductKeyCheck::instance()->licenseAcceptanceText(); + if (!acceptanceText.isEmpty()) { + qCDebug(QInstaller::lcInstallerInstallLog).noquote() << acceptanceText; + if (!m_autoAcceptLicenses && !acceptRejectCliQuery()) + return false; + } + QHash<QString, QMap<QString, QString>> priorityHash = m_core->sortedLicenses(); QStringList priorities = priorityHash.keys(); priorities.sort(); @@ -2839,6 +3435,23 @@ bool PackageManagerCorePrivate::askUserAcceptLicense(const QString &name, const } } +bool PackageManagerCorePrivate::acceptRejectCliQuery() const +{ + forever { + const QString input = m_core->readConsoleLine(QLatin1String("Accept|Reject")); + + if (QString::compare(input, QLatin1String("Accept"), Qt::CaseInsensitive) == 0 + || QString::compare(input, QLatin1String("A"), Qt::CaseInsensitive) == 0) { + return true; + } else if (QString::compare(input, QLatin1String("Reject"), Qt::CaseInsensitive) == 0 + || QString::compare(input, QLatin1String("R"), Qt::CaseInsensitive) == 0) { + return false; + } else { + qCDebug(QInstaller::lcInstallerInstallLog) << "Unknown answer:" << input; + } + } +} + bool PackageManagerCorePrivate::askUserConfirmCommand() const { qCDebug(QInstaller::lcInstallerInstallLog) << "Do you want to continue?"; @@ -2873,4 +3486,60 @@ bool PackageManagerCorePrivate::packageNeedsUpdate(const LocalPackage &localPack return updateNeeded; } +void PackageManagerCorePrivate::commitPendingUnstableComponents() +{ + if (m_pendingUnstableComponents.isEmpty()) + return; + + for (auto &componentName : m_pendingUnstableComponents.keys()) { + Component *const component = m_core->componentByName(componentName); + if (!component) { + qCWarning(lcInstallerInstallLog) << "Failure while marking component " + "unstable. No such component exists:" << componentName; + continue; + } + + const QPair<Component::UnstableError, QString> unstableError + = m_pendingUnstableComponents.value(componentName); + + component->setUnstable(unstableError.first, unstableError.second); + } + m_pendingUnstableComponents.clear(); +} + +void PackageManagerCorePrivate::createAutoDependencyHash(const QString &component, const QString &oldDependencies, const QString &newDependencies) +{ + // User might have changed autodependencies with setValue. Remove the old values. + const QStringList oldDependencyList = oldDependencies.split(QInstaller::commaRegExp(), Qt::SkipEmptyParts); + for (const QString &removedDependency : oldDependencyList) { + QStringList value = m_autoDependencyComponentHash.value(removedDependency); + value.removeAll(component); + if (value.isEmpty()) + m_autoDependencyComponentHash.remove(removedDependency); + else + m_autoDependencyComponentHash.insert(removedDependency, value); + } + + const QStringList newDependencyList = newDependencies.split(QInstaller::commaRegExp(), Qt::SkipEmptyParts); + for (const QString &autodepend : newDependencyList) { + QStringList value = m_autoDependencyComponentHash.value(autodepend); + if (!value.contains(component)) { + value.append(component); + m_autoDependencyComponentHash.insert(autodepend, value); + } + } +} + +void PackageManagerCorePrivate::createLocalDependencyHash(const QString &component, const QString &dependencies) +{ + const QStringList localDependencies = dependencies.split(QInstaller::commaRegExp(), Qt::SkipEmptyParts); + for (const QString &depend : localDependencies) { + QStringList value = m_localDependencyComponentHash.value(depend); + if (!value.contains(component)) { + value.append(component); + m_localDependencyComponentHash.insert(depend, value); + } + } +} + } // namespace QInstaller |