3#include "resources/config.h"
8#include <c++utilities/application/argumentparser.h>
12#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
13#include <c++utilities/io/ansiescapecodes.h>
14#include <c++utilities/io/archive.h>
16#include <QCoreApplication>
20#include <QFutureWatcher>
22#include <QJsonDocument>
24#include <QJsonParseError>
25#include <QNetworkAccessManager>
26#include <QNetworkReply>
27#include <QRegularExpression>
28#include <QStringBuilder>
29#include <QVersionNumber>
30#include <QtConcurrentRun>
33#if defined(QT_UTILITIES_GUI_QTWIDGETS)
40#if defined(QT_UTILITIES_GUI_QTWIDGETS)
41#include <QCoreApplication>
44#if defined(QT_UTILITIES_SETUP_TOOLS_ENABLED)
45#include "ui_updateoptionpage.h"
49class UpdateOptionPage {
51 void setupUi(QWidget *)
54 void retranslateUi(QWidget *)
63#include "resources/config.h"
65#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
66#define QT_UTILITIES_VERSION_SUFFIX QString()
68#define QT_UTILITIES_VERSION_SUFFIX QStringLiteral("-qt5")
71#if defined(Q_OS_WINDOWS)
72#define QT_UTILITIES_EXE_REGEX "\\.exe"
74#define QT_UTILITIES_EXE_REGEX ""
77#if defined(Q_OS_WIN64)
78#if defined(Q_PROCESSOR_X86_64)
79#define QT_UTILITIES_DOWNLOAD_REGEX "-.*-x86_64-w64-mingw32"
80#elif defined(Q_PROCESSOR_ARM_64)
81#define QT_UTILITIES_DOWNLOAD_REGEX "-.*-aarch64-w64-mingw32"
83#elif defined(Q_OS_WIN32)
84#define QT_UTILITIES_DOWNLOAD_REGEX "-.*-i686-w64-mingw32"
85#elif defined(__GNUC__) && defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)
86#if defined(Q_PROCESSOR_X86_64)
87#define QT_UTILITIES_DOWNLOAD_REGEX "-.*-x86_64-pc-linux-gnu"
88#elif defined(Q_PROCESSOR_ARM_64)
89#define QT_UTILITIES_DOWNLOAD_REGEX "-.*-aarch64-pc-linux-gnu"
95#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
96struct UpdateNotifierPrivate {
97 QNetworkAccessManager *nm =
nullptr;
98 CppUtilities::DateTime lastCheck;
99 QNetworkRequest::CacheLoadControl cacheLoadControl = QNetworkRequest::PreferNetwork;
100 QVersionNumber currentVersion = QVersionNumber();
101 QRegularExpression gitHubRegex = QRegularExpression(QStringLiteral(
".*/github.com/([^/]+)/([^/]+)(/.*)?"));
102 QRegularExpression gitHubRegex2 = QRegularExpression(QStringLiteral(
".*/([^/.]+)\\.github.io/([^/]+)(/.*)?"));
103 QRegularExpression assetRegex = QRegularExpression();
104 QString executableName;
106 QString latestVersion;
107 QString additionalInfo;
112 bool inProgress =
false;
113 bool updateAvailable =
false;
114 bool verbose =
false;
126#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
129 m_p->verbose = qEnvironmentVariableIntValue(PROJECT_VARNAME_UPPER
"_UPDATER_VERBOSE");
131 const auto &appInfo = CppUtilities::applicationInfo;
132 const auto url = QString::fromUtf8(appInfo.url);
133 auto gitHubMatch = m_p->gitHubRegex.match(url);
134 if (!gitHubMatch.hasMatch()) {
135 gitHubMatch = m_p->gitHubRegex2.match(url);
137 const auto gitHubOrga = gitHubMatch.captured(1);
138 const auto gitHubRepo = gitHubMatch.captured(2);
139 if (gitHubOrga.isNull() || gitHubRepo.isNull()) {
144 = QStringLiteral(
"https://api.github.com/repos/") % gitHubOrga % QChar(
'/') % gitHubRepo % QStringLiteral(
"/releases?per_page=25");
145 m_p->currentVersion = QVersionNumber::fromString(QLatin1String(appInfo.version));
146#ifdef QT_UTILITIES_DOWNLOAD_REGEX
147 m_p->assetRegex = QRegularExpression(m_p->executableName + QStringLiteral(QT_UTILITIES_DOWNLOAD_REGEX
"\\..+"));
150 qDebug() <<
"deduced executable name: " << m_p->executableName;
151 qDebug() <<
"assumed current version: " << m_p->currentVersion;
152 qDebug() <<
"asset regex for current platform: " << m_p->assetRegex;
158#ifdef QT_UTILITIES_FAKE_NEW_VERSION_AVAILABLE
159 QTimer::singleShot(10000, Qt::VeryCoarseTimer,
this, [
this] { emit
updateAvailable(QStringLiteral(
"foo"), QString()); });
169#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
172 return !m_p->assetRegex.pattern().isEmpty();
178#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
181 return m_p->inProgress;
187#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
190 return m_p->updateAvailable;
196#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
197 static const auto v = QString();
200 return m_p->executableName;
206#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
207 static const auto v = QString();
210 return m_p->newVersion;
216#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
217 static const auto v = QString();
220 return m_p->latestVersion;
226#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
227 static const auto v = QString();
230 return m_p->additionalInfo;
241#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
242 static const auto v = QUrl();
245 return m_p->downloadUrl;
251#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
252 static const auto v = QUrl();
255 return m_p->signatureUrl;
261#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
262 return CppUtilities::DateTime();
264 return m_p->lastCheck;
270#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
273 settings->beginGroup(QStringLiteral(
"updating"));
274 m_p->newVersion = settings->value(
"newVersion").toString();
275 m_p->latestVersion = settings->value(
"latestVersion").toString();
276 m_p->downloadUrl = settings->value(
"downloadUrl").toUrl();
277 m_p->signatureUrl = settings->value(
"signatureUrl").toUrl();
278 m_p->lastCheck = CppUtilities::DateTime(settings->value(
"lastCheck").toULongLong());
279 settings->endGroup();
285#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
288 settings->beginGroup(QStringLiteral(
"updating"));
289 settings->setValue(
"newVersion", m_p->newVersion);
290 settings->setValue(
"latestVersion", m_p->latestVersion);
291 settings->setValue(
"downloadUrl", m_p->downloadUrl);
292 settings->setValue(
"signatureUrl", m_p->signatureUrl);
293 settings->setValue(
"lastCheck",
static_cast<qulonglong
>(m_p->lastCheck.ticks()));
294 settings->endGroup();
300#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
301 if (m_p->inProgress) {
302 return tr(
"checking …");
305 if (!m_p->error.isEmpty()) {
306 return tr(
"unable to check: %1").arg(m_p->error);
308#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
309 if (!m_p->newVersion.isEmpty()) {
310 return tr(
"new version available: %1 (last checked: %2)").arg(m_p->newVersion, QString::fromStdString(m_p->lastCheck.toIsoString()));
311 }
else if (!m_p->latestVersion.isEmpty()) {
312 return tr(
"no new version available, latest release is: %1 (last checked: %2)")
313 .arg(m_p->latestVersion, QString::fromStdString(m_p->lastCheck.toIsoString()));
316 return tr(
"unknown");
321#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
328#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
329void UpdateNotifier::setCacheLoadControl(QNetworkRequest::CacheLoadControl cacheLoadControl)
331 m_p->cacheLoadControl = cacheLoadControl;
335void UpdateNotifier::setError(
const QString &context, QNetworkReply *reply)
337#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
341 m_p->error = context + reply->errorString();
347void UpdateNotifier::setError(
const QString &context,
const QJsonParseError &jsonError,
const QByteArray &response, QNetworkReply *)
349#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
354 m_p->error = context % jsonError.errorString() % QChar(
' ') % QChar(
'(') % tr(
"at offset %1").arg(jsonError.offset) % QChar(
')');
355 if (!response.isEmpty()) {
356 m_p->error += QStringLiteral(
"\nResponse was: ");
357 m_p->error += QString::fromUtf8(response);
365#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
366 m_p->error = tr(
"This build of the application does not support checking for updates.");
370 if (!m_p->nm || m_p->inProgress) {
374 auto request = QNetworkRequest(m_p->releasesUrl);
375 request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, m_p->cacheLoadControl);
376 auto *
const reply = m_p->nm->get(request);
377 connect(reply, &QNetworkReply::finished,
this, &UpdateNotifier::readReleases);
383#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
384 m_p->updateAvailable =
false;
385 m_p->downloadUrl.clear();
386 m_p->signatureUrl.clear();
387 m_p->latestVersion.clear();
388 m_p->newVersion.clear();
392void UpdateNotifier::lastCheckNow()
const
394#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
395 m_p->lastCheck = CppUtilities::DateTime::now();
399void UpdateNotifier::readReleases()
401#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
402 auto *
const reply =
static_cast<QNetworkReply *
>(sender());
403 reply->deleteLater();
404 switch (reply->error()) {
405 case QNetworkReply::NoError: {
407 auto jsonError = QJsonParseError();
408 const auto response = reply->readAll();
409 const auto replyDoc = QJsonDocument::fromJson(response, &jsonError);
410 if (jsonError.error != QJsonParseError::NoError) {
411 setError(tr(
"Unable to parse releases: "), jsonError, response, reply);
415#if !defined(QT_JSON_READONLY)
417 qDebug().noquote() <<
"Update check: found releases: " << QString::fromUtf8(replyDoc.toJson(QJsonDocument::Indented));
420 const auto replyArray = replyDoc.array();
421 auto latestVersionFound = QVersionNumber();
422 auto latestVersionAsset = QJsonValue();
423 for (
const auto &releaseInfoVal : replyArray) {
424 const auto releaseInfo = releaseInfoVal.toObject();
425 const auto tag = releaseInfo.value(QLatin1String(
"tag_name")).toString();
426 if (releaseInfo.value(QLatin1String(
"prerelease")).toBool() || releaseInfo.value(QLatin1String(
"draft")).toBool()) {
427 qDebug() <<
"Update check: skipping prerelease/draft: " << tag;
430 const auto version = QVersionNumber::fromString(tag.startsWith(QChar(
'v')) ? tag.mid(1) : tag);
431 const auto assets = releaseInfo.value(QLatin1String(
"assets"));
432 if (latestVersionFound.isNull() || version > latestVersionFound) {
433 latestVersionFound = version;
434 latestVersionAsset = assets;
436 if (!version.isNull() && version > m_p->currentVersion) {
437 m_p->latestVersion = latestVersionFound.toString();
438 m_p->newVersion = version.toString();
439 if (assets.isArray()) {
440 processAssets(assets.toArray(),
true);
443 queryRelease(releaseInfo.value(QLatin1String(
"assets_url")).toString());
448 qDebug() <<
"Update check: skipping release: " << tag;
451 m_p->latestVersion = latestVersionFound.toString();
452 if (latestVersionAsset.isArray()) {
453 processAssets(latestVersionAsset.toArray(),
false);
459 case QNetworkReply::OperationCanceledError:
463 setError(tr(
"Unable to request releases: "), reply);
468void UpdateNotifier::queryRelease(
const QUrl &releaseUrl)
470#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
473 auto request = QNetworkRequest(releaseUrl);
474 request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, m_p->cacheLoadControl);
475 auto *
const reply = m_p->nm->get(request);
476 connect(reply, &QNetworkReply::finished,
this, &UpdateNotifier::readRelease);
480void UpdateNotifier::readRelease()
482#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
483 auto *
const reply =
static_cast<QNetworkReply *
>(sender());
484 reply->deleteLater();
485 switch (reply->error()) {
486 case QNetworkReply::NoError: {
488 auto jsonError = QJsonParseError();
489 const auto response = reply->readAll();
490 const auto replyDoc = QJsonDocument::fromJson(response, &jsonError);
491 if (jsonError.error != QJsonParseError::NoError) {
492 setError(tr(
"Unable to parse release: "), jsonError, response, reply);
495#if !defined(QT_JSON_READONLY)
497 qDebug().noquote() <<
"Update check: found release info: " << QString::fromUtf8(replyDoc.toJson(QJsonDocument::Indented));
500 processAssets(replyDoc.object().value(QLatin1String(
"assets")).toArray(),
true);
504 case QNetworkReply::OperationCanceledError:
508 setError(tr(
"Unable to request release: "), reply);
513void UpdateNotifier::processAssets(
const QJsonArray &assets,
bool forUpdate)
515#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
519 for (
const auto &assetVal : assets) {
520 if (!m_p->downloadUrl.isEmpty() && !m_p->signatureUrl.isEmpty()) {
523 const auto asset = assetVal.toObject();
524 const auto assetName = asset.value(QLatin1String(
"name")).toString();
525 if (assetName.isEmpty()) {
528 if (m_p->assetRegex.match(assetName).hasMatch()) {
529 const auto url = asset.value(QLatin1String(
"browser_download_url")).toString();
530 if (assetName.endsWith(QLatin1String(
".sig"))) {
531 m_p->signatureUrl = url;
533 m_p->downloadUrl = url;
538 qDebug() <<
"Update check: skipping asset: " << assetName;
542 m_p->updateAvailable = !m_p->downloadUrl.isEmpty();
545 if (m_p->updateAvailable) {
551#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
553 QNetworkAccessManager *nm =
nullptr;
554 QFile *fakeDownload =
nullptr;
555 QNetworkReply *currentDownload =
nullptr;
556 QNetworkReply *signatureDownload =
nullptr;
557 QNetworkRequest::CacheLoadControl cacheLoadControl = QNetworkRequest::PreferNetwork;
558 QString
error, statusMessage;
559 QByteArray signature;
560 QFutureWatcher<QPair<QString, QString>> watcher;
561 QString executableName;
562 QString signatureExtension;
563 QRegularExpression executableRegex = QRegularExpression();
574 :
Updater(executableName, QString(), parent)
578Updater::Updater(
const QString &executableName,
const QString &signatureExtension, QObject *parent)
582#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
583 Q_UNUSED(executableName)
584 Q_UNUSED(signatureExtension)
586 connect(&m_p->watcher, &QFutureWatcher<void>::finished,
this, &Updater::concludeUpdate);
587 m_p->executableName = executableName;
588 m_p->signatureExtension = signatureExtension;
589 const auto signatureRegex = signatureExtension.isEmpty()
591 : QString(QStringLiteral(
"(") % QRegularExpression::escape(signatureExtension) % QStringLiteral(
")?"));
592#ifdef QT_UTILITIES_EXE_REGEX
593 m_p->executableRegex = QRegularExpression(executableName % QStringLiteral(
QT_UTILITIES_EXE_REGEX) % signatureRegex);
604#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
605 return m_p->currentDownload !=
nullptr || m_p->signatureDownload !=
nullptr || m_p->watcher.isRunning();
613#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
614 return isInProgress() ? tr(
"Update in progress …") : (m_p->error.isEmpty() ? tr(
"Update done") : tr(
"Update failed"));
627#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
628 return m_p->statusMessage.isEmpty() ? m_p->error : m_p->statusMessage;
636#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
637 return m_p->storedPath;
639 static const auto empty = QString();
646#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
655#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
656 m_p->verifyFunction = std::move(verifyFunction);
658 Q_UNUSED(verifyFunction)
662#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
663void Updater::setCacheLoadControl(QNetworkRequest::CacheLoadControl cacheLoadControl)
665 m_p->cacheLoadControl = cacheLoadControl;
671#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
672 Q_UNUSED(downloadUrl)
673 Q_UNUSED(signatureUrl)
674 setError(tr(
"This build of the application does not support self-updating."));
680 startDownload(downloadUrl, signatureUrl);
687#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
688 if (m_p->currentDownload) {
689 m_p->currentDownload->abort();
691 if (m_p->signatureDownload) {
692 m_p->signatureDownload->abort();
694 if (m_p->watcher.isRunning()) {
695 m_p->watcher.cancel();
700void Updater::setError(
const QString &error)
702#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
703 m_p->statusMessage.clear();
711void Updater::startDownload(
const QString &downloadUrl,
const QString &signatureUrl)
713#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
714 Q_UNUSED(downloadUrl)
715 Q_UNUSED(signatureUrl)
718 m_p->storedPath.clear();
719 m_p->signature.clear();
721 if (
const auto fakeDownloadPath = qEnvironmentVariable(PROJECT_VARNAME_UPPER
"_UPDATER_FAKE_DOWNLOAD"); !fakeDownloadPath.isEmpty()) {
722 m_p->fakeDownload =
new QFile(fakeDownloadPath);
723 m_p->fakeDownload->open(QFile::ReadOnly);
729 auto request = QNetworkRequest(QUrl(downloadUrl));
730 request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, m_p->cacheLoadControl);
731 m_p->statusMessage = tr(
"Downloading %1").arg(downloadUrl);
732 m_p->currentDownload = m_p->nm->get(request);
736 connect(m_p->currentDownload, &QNetworkReply::finished,
this, &Updater::handleDownloadFinished);
738 if (!signatureUrl.isEmpty()) {
739 request.setUrl(signatureUrl);
740 m_p->signatureDownload = m_p->nm->get(request);
741 connect(m_p->signatureDownload, &QNetworkReply::finished,
this, &Updater::handleDownloadFinished);
746void Updater::handleDownloadFinished()
748#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
749 if (m_p->signatureDownload && !m_p->signatureDownload->isFinished()) {
754 if (!m_p->currentDownload->isFinished()) {
758 if (m_p->signatureDownload) {
760 m_p->signatureDownload->deleteLater();
761 m_p->signatureDownload =
nullptr;
764 if (m_p->error.isEmpty()) {
767 m_p->currentDownload->deleteLater();
769 m_p->currentDownload =
nullptr;
773void Updater::readSignature()
775#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
776 switch (m_p->signatureDownload->error()) {
777 case QNetworkReply::NoError:
778 m_p->signature = m_p->signatureDownload->readAll();
781 setError(tr(
"Unable to download signature: ") + m_p->signatureDownload->errorString());
786void Updater::storeExecutable()
788#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
789 m_p->statusMessage = tr(
"Extracting …");
792 auto *reply =
static_cast<QIODevice *
>(m_p->fakeDownload);
793 auto archiveName = QString();
794 auto hasError =
false;
796 archiveName = m_p->fakeDownload->fileName();
797 hasError = m_p->fakeDownload->error() != QFileDevice::NoError;
799 reply = m_p->currentDownload;
800 archiveName = m_p->currentDownload->request().url().fileName();
801 hasError = m_p->currentDownload->error() != QNetworkReply::NoError;
804 reply->deleteLater();
805 setError(tr(
"Unable to download update: ") + reply->errorString());
808 auto res = QtConcurrent::run([
this, reply, archiveName] {
809 const auto data = reply->readAll();
810 const auto dataView = std::string_view(data.data(),
static_cast<std::size_t
>(data.size()));
811 auto foundExecutable =
false, foundSignature =
false;
812 auto error = QString(), storePath = QString();
813 auto newExeName = std::string(), signatureName = std::string();
814 auto newExeData = std::string();
815 auto newExe = QFile();
816 reply->deleteLater();
819 const auto appDirPath = QCoreApplication::applicationDirPath();
820 const auto appFilePath = QCoreApplication::applicationFilePath();
821 if (appDirPath.isEmpty() || appFilePath.isEmpty()) {
822 error = tr(
"Unable to determine application path.");
823 return QPair<QString, QString>(
error, storePath);
827 const auto checkCancellation = [
this, &
error] {
828 if (m_p->watcher.isCanceled()) {
829 error = tr(
"Extraction was cancelled.");
835 if (checkCancellation()) {
836 return QPair<QString, QString>(
error, storePath);
840 CppUtilities::walkThroughArchiveFromBuffer(
841 dataView, archiveName.toStdString(),
842 [
this](
const char *filePath,
const char *fileName, mode_t mode) {
845 if (m_p->watcher.isCanceled()) {
848 return m_p->executableRegex.match(QString::fromUtf8(fileName)).hasMatch();
850 [&](std::string_view path, CppUtilities::ArchiveFile &&file) {
852 if (checkCancellation()) {
855 if (file.type != CppUtilities::ArchiveFileType::Regular) {
860 const auto fileName = QString::fromUtf8(file.name.data(),
static_cast<QString::size_type
>(file.name.size()));
861 if (!m_p->signatureExtension.isEmpty() && fileName.endsWith(m_p->signatureExtension)) {
862 m_p->signature = QByteArray::fromStdString(file.content);
863 foundSignature =
true;
864 signatureName = file.name;
865 return foundExecutable && foundSignature;
869 foundExecutable =
true;
870 newExeName = file.name;
871 newExe.setFileName(appDirPath % QChar(
'/') % fileName % QStringLiteral(
".tmp"));
872 if (!newExe.open(QFile::WriteOnly | QFile::Truncate)) {
873 error = tr(
"Unable to create new executable under \"%1\": %2").arg(newExe.fileName(), newExe.errorString());
876 const auto size =
static_cast<qint64
>(file.content.size());
877 if (!(newExe.write(file.content.data(), size) == size) || !newExe.flush()) {
878 error = tr(
"Unable to write new executable under \"%1\": %2").arg(newExe.fileName(), newExe.errorString());
881 if (!newExe.setPermissions(
882 newExe.permissions() | QFileDevice::ExeOwner | QFileDevice::ExeUser | QFileDevice::ExeGroup | QFileDevice::ExeOther)) {
883 error = tr(
"Unable to make new binary under \"%1\" executable.").arg(newExe.fileName());
887 storePath = newExe.fileName();
888 newExeData = std::move(file.content);
889 return foundExecutable && foundSignature;
891 }
catch (
const CppUtilities::ArchiveException &e) {
892 error = tr(
"Unable to open downloaded archive: %1").arg(e.what());
894 if (
error.isEmpty() && foundExecutable) {
896 if (m_p->verifyFunction) {
897 if (const auto verifyError = m_p->verifyFunction(Updater::Update{ .executableName = newExeName,
898 .signatureName = signatureName,
900 .signature = std::string_view(m_p->signature.data(), static_cast<std::size_t>(m_p->signature.size())) });
901 !verifyError.isEmpty()) {
902 error = tr(
"Unable to verify whether downloaded binary is valid: %1").arg(verifyError);
903 return QPair<QString, QString>(error, storePath);
908 auto currentExeInfo = QFileInfo(appFilePath);
909 auto currentExe = QFile(appFilePath);
910 const auto completeSuffix = currentExeInfo.completeSuffix();
911 const auto suffixWithDot = completeSuffix.isEmpty() ? QString() : QChar(
'.') + completeSuffix;
912 for (
auto i = 0; i < 100; ++i) {
913 const auto backupNumber = i ? QString::number(i) : QString();
914 const auto backupPath = QString(currentExeInfo.path() % QChar(
'/') % currentExeInfo.baseName() % QStringLiteral(
"-backup")
915 % backupNumber % QChar(
'-') % QString::fromUtf8(CppUtilities::applicationInfo.version) % suffixWithDot);
916 if (QFile::exists(backupPath)) {
919 if (!currentExe.rename(backupPath)) {
920 error = tr(
"Unable to move current executable to \"%1\": %2").arg(backupPath, currentExe.errorString());
921 return QPair<QString, QString>(
error, storePath);
927 if (!newExe.rename(appFilePath)) {
928 error = tr(
"Unable to rename new executable \"%1\" to \"%2\": %3").arg(newExe.fileName(), appFilePath, newExe.errorString());
929 return QPair<QString, QString>(error, storePath);
931 storePath = newExe.fileName();
933 if (error.isEmpty() && !foundExecutable) {
934 error = tr(
"Unable to find executable in downloaded archive.");
936 return QPair<QString, QString>(error, storePath);
938 m_p->watcher.setFuture(std::move(res));
942void Updater::concludeUpdate()
944#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
945 auto res = m_p->watcher.result();
946 m_p->error = res.first;
947 m_p->storedPath = res.second;
948 if (!m_p->error.isEmpty()) {
949 m_p->statusMessage.clear();
950 emit updateFailed(m_p->error);
952 m_p->statusMessage = tr(
"Update stored under: %1").arg(m_p->storedPath);
955 emit updateStatusChanged(statusMessage());
956 emit updatePercentageChanged(0, 0);
957 emit inProgressChanged(
false);
963 :
updater(executableName.isEmpty() ?
notifier.executableName() : executableName, signatureExtension)
990 const QString &executableName,
const QString &signatureExtension, QSettings *settings, QNetworkAccessManager *nm, QObject *parent)
994 m_p->notifier.setNetworkAccessManager(nm);
995 m_p->updater.setNetworkAccessManager(nm);
996 m_p->timer.setSingleShot(
true);
997 m_p->timer.setTimerType(Qt::VeryCoarseTimer);
998 m_p->settings = settings;
1009 return &m_p->notifier;
1014 return &m_p->updater;
1019 if (m_p->checkInterval.has_value()) {
1020 return m_p->checkInterval.value();
1022 m_p->settings->beginGroup(QStringLiteral(
"updating"));
1024 checkInterval.duration = CppUtilities::TimeSpan::fromMilliseconds(m_p->settings->value(
"checkIntervalMs", 60 * 60 * 1000).toInt());
1025 checkInterval.enabled = m_p->settings->value(
"automaticChecksEnabled",
false).toBool();
1026 m_p->settings->endGroup();
1033 m_p->settings->beginGroup(QStringLiteral(
"updating"));
1034 m_p->settings->setValue(
"checkIntervalMs",
checkInterval.duration.totalMilliseconds());
1035 m_p->settings->setValue(
"automaticChecksEnabled",
checkInterval.enabled);
1036 m_p->settings->endGroup();
1037#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1038 scheduleNextUpdateCheck();
1044 return m_p->considerSeparateSignature;
1049 m_p->considerSeparateSignature = consideringSeparateSignature;
1052#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1053void UpdateHandler::setCacheLoadControl(QNetworkRequest::CacheLoadControl cacheLoadControl)
1055 m_p->notifier.setCacheLoadControl(cacheLoadControl);
1056 m_p->updater.setCacheLoadControl(cacheLoadControl);
1062#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1063 m_p->notifier.restore(m_p->settings);
1064 scheduleNextUpdateCheck();
1070 m_p->updater.performUpdate(
1071 m_p->notifier.downloadUrl().toString(), m_p->considerSeparateSignature ? m_p->notifier.signatureUrl().toString() : QString());
1074void UpdateHandler::handleUpdateCheckDone()
1076#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1077 m_p->notifier.save(m_p->settings);
1078 scheduleNextUpdateCheck();
1082#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1083void UpdateHandler::scheduleNextUpdateCheck()
1088 if (!interval.enabled || (interval.duration.isNull() && m_p->hasCheckedOnceSinceStartup)) {
1091 const auto timeLeft = interval.duration - (CppUtilities::DateTime::now() - m_p->notifier.lastCheck());
1092 std::cerr << CppUtilities::EscapeCodes::Phrases::Info
1093 <<
"Check for updates due in: " << timeLeft.toString(CppUtilities::TimeSpanOutputFormat::WithMeasures)
1094 << CppUtilities::EscapeCodes::Phrases::End;
1095 m_p->hasCheckedOnceSinceStartup =
true;
1096 m_p->timer.start(std::max(1000,
static_cast<int>(timeLeft.totalMilliseconds())));
1100#ifdef QT_UTILITIES_GUI_QTWIDGETS
1101struct UpdateOptionPagePrivate {
1102 UpdateOptionPagePrivate(UpdateHandler *updateHandler)
1103 : updateHandler(updateHandler)
1106 UpdateHandler *updateHandler =
nullptr;
1107 std::function<void()> restartHandler;
1110UpdateOptionPage::UpdateOptionPage(
UpdateHandler *updateHandler, QWidget *parentWidget)
1111 : UpdateOptionPageBase(parentWidget)
1112#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1113 , m_p(std::make_unique<UpdateOptionPagePrivate>(updateHandler))
1116#ifndef QT_UTILITIES_SETUP_TOOLS_ENABLED
1117 Q_UNUSED(updateHandler)
1121UpdateOptionPage::~UpdateOptionPage()
1125void UpdateOptionPage::setRestartHandler(std::function<
void()> &&handler)
1127 m_p->restartHandler = std::move(handler);
1130bool UpdateOptionPage::apply()
1132#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1133 if (!m_p->updateHandler) {
1137 .duration = CppUtilities::TimeSpan::fromMinutes(ui()->checkIntervalSpinBox->value()), .enabled = ui()->enabledCheckBox->isChecked() });
1142void UpdateOptionPage::reset()
1144#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1145 if (!m_p->updateHandler) {
1148 const auto &checkInterval = m_p->updateHandler->checkInterval();
1149 ui()->checkIntervalSpinBox->setValue(
static_cast<int>(checkInterval.duration.totalMinutes()));
1150 ui()->enabledCheckBox->setChecked(checkInterval.enabled);
1154QWidget *UpdateOptionPage::setupWidget()
1156#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1158 if (m_p->updateHandler && m_p->updateHandler->notifier()->isSupported()) {
1159 auto *
const widget = UpdateOptionPageBase::setupWidget();
1160 ui()->versionInUseValueLabel->setText(QString::fromUtf8(CppUtilities::applicationInfo.version));
1161 ui()->updateWidget->hide();
1162 updateLatestVersion();
1165 QObject::connect(ui()->abortUpdatePushButton, &QPushButton::clicked, m_p->updateHandler->updater(), &
Updater::abortUpdate);
1166 QObject::connect(ui()->restartPushButton, &QPushButton::clicked, widget, m_p->restartHandler);
1170 const auto *const updater = m_p->updateHandler->updater();
1171 ui()->updateWidget->setVisible(true);
1172 ui()->updateInProgressLabel->setText(updater->overallStatus());
1173 ui()->updateProgressBar->setVisible(inProgress);
1174 ui()->abortUpdatePushButton->setVisible(inProgress);
1175 ui()->restartPushButton->setVisible(!inProgress && !updater->storedPath().isEmpty() && updater->error().isEmpty());
1178 [
this](
const QString &statusMessage) { ui()->updateStatusLabel->setText(statusMessage); });
1180 if (bytesTotal == 0) {
1181 ui()->updateProgressBar->setMaximum(0);
1183 ui()->updateProgressBar->setValue(static_cast<int>(bytesReceived * 100 / bytesTotal));
1184 ui()->updateProgressBar->setMaximum(100);
1191 auto *
const label =
new QLabel;
1192 label->setWindowTitle(QCoreApplication::translate(
"QtGui::UpdateOptionPage",
"Updating"));
1193 label->setAlignment(Qt::AlignCenter);
1194 label->setWordWrap(
true);
1195#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1196 label->setText(QCoreApplication::translate(
"QtUtilities::UpdateOptionPage",
"Checking for updates is not supported on this platform."));
1198 label->setText(QCoreApplication::translate(
"QtUtilities::UpdateOptionPage",
1199 "This build of %1 has automatic updates disabled. You may update the application in an automated way via your package manager, though.")
1200 .arg(CppUtilities::applicationInfo.name));
1205void UpdateOptionPage::updateLatestVersion(
bool)
1207#ifdef QT_UTILITIES_SETUP_TOOLS_ENABLED
1208 if (!m_p->updateHandler) {
1211 const auto ¬ifier = *m_p->updateHandler->notifier();
1212 const auto &downloadUrl = notifier.downloadUrl();
1213 const auto downloadUrlEscaped = downloadUrl.toString().toHtmlEscaped();
1214 ui()->latestVersionValueLabel->setText(notifier.status());
1215 ui()->downloadUrlLabel->setText(downloadUrl.isEmpty()
1216 ? (notifier.latestVersion().isEmpty()
1217 ? QCoreApplication::translate(
"QtUtilities::UpdateOptionPage",
"no new version available for download")
1218 : QCoreApplication::translate(
1219 "QtUtilities::UpdateOptionPage",
"new version available but no build for the current platform present yet"))
1220 : (QStringLiteral(
"<a href=\"") % downloadUrlEscaped % QStringLiteral(
"\">") % downloadUrlEscaped % QStringLiteral(
"</a>")));
1221 ui()->updatePushButton->setDisabled(downloadUrl.isEmpty());
1229#if defined(QT_UTILITIES_GUI_QTWIDGETS)
The UpdateHandler class manages the non-graphical aspects of checking for new updates and performing ...
~UpdateHandler() override
bool isConsideringSeparateSignature() const
void setConsideringSeparateSignature(bool consideringSeparateSignature)
UpdateHandler(QSettings *settings, QNetworkAccessManager *nm, QObject *parent=nullptr)
Handles checking for updates and performing an update of the application if available.
const CheckInterval & checkInterval() const
UpdateNotifier * notifier
void setCheckInterval(CheckInterval checkInterval)
The UpdateNotifier class allows checking for new updates.
void setNetworkAccessManager(QNetworkAccessManager *nm)
UpdateNotifier(QObject *parent=nullptr)
void save(QSettings *settings)
bool isInProgress() const
bool isUpdateAvailable() const
void inProgressChanged(bool inProgress)
const QString & latestVersion() const
void restore(QSettings *settings)
CppUtilities::DateTime lastCheck() const
~UpdateNotifier() override
The Updater class allows downloading and applying an update.
Updater(const QString &executableName, QObject *parent=nullptr)
void updatePercentageChanged(qint64 bytesReceived, qint64 bytesTotal)
void updateStatusChanged(const QString &statusMessage)
void updateFailed(const QString &error)
std::function< QString(const Update &)> VerifyFunction
bool performUpdate(const QString &downloadUrl, const QString &signatureUrl)
void setVerifier(VerifyFunction &&verifyFunction)
void inProgressChanged(bool inProgress)
void setNetworkAccessManager(QNetworkAccessManager *nm)
bool isInProgress() const
#define INSTANTIATE_UI_FILE_BASED_OPTION_PAGE(SomeClass)
Instantiates a class declared with BEGIN_DECLARE_UI_FILE_BASED_OPTION_PAGE in a convenient way.
bool considerSeparateSignature
UpdateHandlerPrivate(const QString &executableName, const QString &signatureExtension)
std::optional< UpdateHandler::CheckInterval > checkInterval
bool hasCheckedOnceSinceStartup
The CheckInterval struct specifies whether automatic checks for updates are enabled and of often they...
#define QT_UTILITIES_EXE_REGEX
#define QT_UTILITIES_VERSION_SUFFIX