Updating main QT application using updater application

[hskoglund]

Hi, if you're only targeting Windows (and not MacOS or Linux) then you could try an alternative approach, using the fact that on Windows, while you cannot delete the app while it's running, you can rename it, like this:

1. delete any old detritus i.e. "TestToolOldVersion.exe"
2. the app renames itself from "TestTool.exe" to "TestToolOldVersion.exe"
3. the app continues with downloading, unzipping and installing the new .exe with the name "TestTool.exe"

Optional steps:
4) when the app exits, try starting a .bat file that deletes "TestToolOldVersion.exe"
5) when the app starts, check the filename, if it is "TestToolOldVersion.exe" that is started by mistake, issue an error or try to start the real "TestTool.exe"

[lukutis222]

@hskoglund

Thanks for suggestions. I could not fully understand what you mean, but since you mentioned I can rename the name of the exe while it is still running, I have made the following modifications:

In my main application applyUpdate method, after starting updater.exe I no longer quit application:

void FileDownloader::applyUpdate() {
    // Set the path to the zip file and the destination directory

    QString zipFilePath = QCoreApplication::applicationDirPath() + "/update.zip";
    qDebug("Expected zip location = %s \n",zipFilePath.toStdString().c_str());
    QString destinationDir = QCoreApplication::applicationDirPath() + "/update";

    // Create the destination directory if it does not exist
    QDir dir(destinationDir);
    if (!dir.exists()) {
        dir.mkpath(destinationDir);
    }

    // Unzip the update.zip file
    QProcess process;
    process.setProgram("unzip");
    process.setArguments(QStringList() << zipFilePath << "-d" << destinationDir);

    // Start the process and wait for it to finish
    process.start();
    if (!process.waitForFinished()) {
        qDebug() << "Unzip failed to start: " << process.errorString();
        return;
    }

    // Check the exit status
    if (process.exitStatus() != QProcess::NormalExit || process.exitCode() != 0) {
        qDebug() << "Unzip failed with exit code: " << process.exitCode();
        qDebug() << "Error output: " << process.readAllStandardError();
        return;
    }

    qDebug() << "Unzip completed successfully.";

    // Proceed with the update (e.g., replace old executable, etc.)
    QString oldExecutable = QCoreApplication::applicationDirPath() + "/TestTool.exe";
    QString newExecutable = destinationDir + "/TestTool.exe";
    QString updaterExecutable = QCoreApplication::applicationDirPath() + "/updater.exe";

    qDebug("old executsble path = %s \n",oldExecutable.toStdString().c_str());
    qDebug("new executsble path = %s \n",newExecutable.toStdString().c_str());
    qDebug("updater executable path = %s\n", updaterExecutable.toStdString().c_str());

    // Start the updater process
    if (!QProcess::startDetached(updaterExecutable, QStringList() << oldExecutable << newExecutable << QString::number(QCoreApplication::applicationPid()))) {
        qDebug() << "Failed to start updater.";
        return;
    }

    //QCoreApplication::quit();

}

I have made the following modifications to updater.exe:
In the performUpdate method, I no longer try to delete an old .exe file. I just simply rename it to TestTool_renamed.exe and I put new TestTool.exe in its place. After that, I am starting detachedProcess with newExecutable. See full method:

void MainWindow::performUpdate()
{
    qDebug() << "Starting update process";


    // Rename old executable
    if (QFile::exists(oldExecutable)) {
        qDebug() << "Rename old executable";
        QFile::rename(oldExecutable,"C:/Users/petrikas.lu/Desktop/WORK/QT/TestTool/TestTool_renamed.exe");
    }

    // Copy the new executable to the application directory
    if (QFile::exists(newExecutable)) {
        qDebug() << "Copying new executable";
        if (!QFile::copy(newExecutable, oldExecutable)) {
            qDebug() << "Failed to copy new executable:";
            return;
        }
    }

        // Kill the old application
        QProcess process;
        process.start("kill", QStringList() << "-0" << QString::number(mainAppPid));
        process.waitForFinished();

    // Restart the application
    qDebug() << "Restarting application";
    QProcess::startDetached(newExecutable);

    
      QCoreApplication::quit();
}

This method works. The only issue now is the old application remains running even after the new is started. So now I have 2 TestTool.exe running (one old version and the other updated).

To solve this issue, I have tried to also add a 3rd argument to my updater.exe (applicationPid). So now my updater.exe takes in 3 arguments:

1. Path to old executable
2. Path to new executable
3. Main applicationPid

I have tried to kill the old application from the updater.exe using the Main applicationPid that is passed as an argument

        // Kill the old application
        QProcess process;
        process.start("kill", QStringList() << "-0" << QString::number(mainAppPid));
        process.waitForFinished();

but it does not work.

[artwaw]

My approach to creating autoupdater was slightly different:

• download the update;
• start the update QProcess as detached https://doc.qt.io/qt-6/qprocess.html#startDetached-1
• if QProcess started succeffuly, self terminate.
  And update QProcess, should everything complete ok, would start the program anew. Can digout the code if one wishes.

My main reasoning was - since the widnows exe can't fully manipulate itself, let it just download the files and handover update to the specified subroutine, then self terminate to let said subroutine work.

[lukutis222]

@artwaw This sound like exactly my approach. Why do you think mine is different?

[artwaw]

@lukutis222

QProcess process;
process.start("kill", QStringList() << "-0" << QString::number(mainAppPid));
process.waitForFinished();

This?

My approach was along the lines:

#routines downloading and verifying update packet here 
bool extStarted = QProcess::startDetached(params_go_here);
#call program shutdown and exit routines here if bool is true

Why would you dabble in calling QProcess to terminate self when it is safer to do so from the inside? I am leaving aside the matter of privileges required for that to succeed.

[JonB]

@lukutis222
Absolutely as @artwaw has written. Additionally what is this kill program you try to run anyway? It does not come with Windows, so if you have it at all you have added it, it won't be present for your other end users. Maybe that's why it doesn't work for you either!

[lukutis222]

@artwaw

But that is exactly what I do after my failed attempt to kill the old process:

    // Kill the old application
    QProcess process;
    process.start("kill", QStringList() << "-0" << QString::number(mainAppPid));
    process.waitForFinished();


    // Restart the application
    qDebug() << "Restarting application";
    QProcess::startDetached(newExecutable);


    QCoreApplication::quit();

As you can see from above, I am starting the newExecutable as new detached process which I assumed is what you mean. The only problem as I have previously mentioned is now I have 2 applications running and I want to kill the old one

[lukutis222]

@JonB
I am trying to kill old application. The process is as following:

1. Run main QT application which starts updater.exe in detached mode but it does not end current application.
2. Updater.exe renames the old application with TestTool_renamed.exe and places new exe as TestTool.exe
3. Updater.exe runs the TestTool.exe as detached process
4. Now I have 2 applications running. I want to kill the old one

I am now looking into what is the best way to end the old application from the updater after it has finished swapping the files. Because as you mentioned, using kill is just not going to work. I wonder if I should be closing old application via the old application itlsef or from the updater as I am currently trying?

[artwaw]

@lukutis222

Always via the old application itself.
The safest way to do so is to call close() method of the main window (which also happens to be a slot should you need it). I don't know why QCoreApplication static call doesn't work but it's not the method one would normally use anyway.

[lukutis222]

@artwaw

#TEST1

In my main application, I can close the application by calling theQCoreApplication::quit() immediately after starting detached application

    // Start the updater process
    if (!QProcess::startDetached(updaterExecutable, QStringList() << oldExecutable << newExecutable << QString::number(QCoreApplication::applicationPid()))) {
        qDebug() << "Failed to start updater.";
        return;
    }

    QCoreApplication::quit();

but if I do that, it does not even start updater.exe detached process which is what I am confused about. Is that expected behaviour?

For testing purposes, I have added 5 seconds sleep before I quite main application after starting updater:

    // Start the updater process
    if (!QProcess::startDetached(updaterExecutable, QStringList() << oldExecutable << newExecutable << QString::number(QCoreApplication::applicationPid()))) {
        qDebug() << "Failed to start updater.";
        return;
    }

    QThread::sleep(5);

    QCoreApplication::quit();

The result is as shown below:

1. Main QT application starts
2. It runs the detached process (updater.exe)
3. Updater exe performs an update and starts a new application
4. Now I have 2 applications running for a brief moment
5. After 5 seconds both applications close

I do not understand why does calling QCoreApplication::quit(); from the main QT application also close a new application that has been started in detached mode from updater.exe

#TEST2

Lets assume my main application will not call quit() after starting updater.exe

1. Main QT application starts
2. Starts updater.exe in detached mode
3. updater updates the TestTool and launches a new application
4. Now I have 2 applications running
5. Trying to manually close old application will cause both applications to close.
6. Trying to manually close new application will not cause old application to close.

I think this is where my issue lies now. Why does new application close when I try to close the old application?

Could that be because:
Since the new updated application is started from the updater and the updater is started from the main "old" application, since the updater is child of an "old" application, closing an old application means closing the updater which as a result closes new updated application because the new updated application is child of updater

Is that how it works?

[artwaw]

@lukutis222 This is indeed a bit peculiar and not an issue I ran into in the past. So perhaps more experienced colleagues here will have an idea? I'd add a 5 seconds delay at the start of the updater, just to make sure original program shuts down (or a flag in the file somewhere that it is closed) so the updater can wait with starting the program again - but that should not be needed in the first place...

[hskoglund]

@lukutis222 you're sure you're using QProcess::startDetached() at all times? Then any spawned child(s) shouldn't die just because the parent dies. (Only exception is when you run the app from the debugger.)

For a quick test, create a new empty vanilla Widget app, and in the MainWindow::MainWindow constructor add:

QProcess::startDetached("c:/windows/notepad.exe");

(don't forget to #include "qprocess.h" at the top)

If you build it (in Release mode) and start it, then Notepad should appear. Then if you kill the app from say Task Manager, Notepad should still be alive and well.

[lukutis222]

Yep you were totally right. I was testing this while running my application in debug mode. If I just simply run the application then it will work without any issues!