Set version to 1.3.14.

Add compile flag -C (so it is possible to use /*fall through*/ without
having the proprocessor to remove this comment.

OnDemandUpdatePTU.pro

@@ -41,9 +41,36 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #           up cloning of customer repository.
 # 1.3.13:   Fix: if the customer repository is corrupted, remove it and re-clone
 #           the repository (without checking the ISMAS-trigger (WAIT-)button.
+VERSION="1.3.14"
 # 1.3.14:   Add additional check for sanity of customer repository using
 #           "git fsck".
-#           Stream-lined code of update process.
+#           Stream-lined code of update process: massive refactoring.
+#           Added functionality: If WAIT button is not active, then an existing
+#           customer repository will be repaired, or a not existing repository
+#           will be cloned. The process stops then.
+#           However, if the WAIT button is active, the at least the commands in
+#           opkg_commands will be executed. Changed files in the customer
+#           repository will be worked on: tariff-files will be synced with the
+#           local filesystem, json-files will be downloaded to firmware.
+#           The device-controller firmware will be handled in a later version.
+
+# PLANNED TODOS:
+#   1:  Das Repository wird repariert bwz. neu geklont. Unabhaengig vom WAIT.
+#   2:  Wenn der WAIT-Button aktiv ist, dann wird ein Repository repariert (neu
+#       geklont), aber zusaetzlich werden alle verfuegbaren Dateien als neu
+#       angesehen und die entsprechenden Aktionen durchgefuehrt: tariff-files
+#       spiegeln, json-files laden und dc laden. Also VORSICHT: das repository
+#       muss in diesem fall wirklich in ordnung sein.
+#   3:  Wurde keine Datei geaendert, kein initiales Clone und der WAIT-button
+#       nicht aktiv, so (passiert natuerlich nichts) kann man davon ausgehen,
+#       dass es sich um ein automatisches Update handelt. Dann koennte man im
+#       ISMAS eine entsprechende Meldung anzeigen als Teil von SEND-LAST-VERSION.
+#       Wenn der WAIT-button aktiv ist, dann werden zumindest die opkg-commands
+#       ausgefuehrt.
+#   4:  rsync: immer alle Dateien soiegeln (bis auf opkg-commands)
+#   5:  Falls das Tool mal abstuerzt, dann einen Signal-Handler (fuer TERM)
+#       installieren, sodass zumnidest SEND-LASt-VERSION mit rausgeht.
+#   6:  rsync: explizites Binary, nicht das in busybox enthaltene.
 
 win32 {
     BUILD_DATE=$$system("date /t")
@@ -55,7 +82,6 @@ win32 {
 
 GIT_COMMIT=$$system("git log -1 --format=oneline | cut -d' ' -f1")
 
-VERSION="1.3.11"
 EXTENDED_VERSION="$${VERSION}-$${GIT_COMMIT}"
 
 INCLUDEPATH += plugins
@@ -68,6 +94,8 @@ DEFINES+=APP_BUILD_DATE=\\\"$$BUILD_DATE\\\"
 DEFINES+=APP_BUILD_TIME=\\\"$$BUILD_TIME\\\"
 DEFINES+=APP_EXTENDED_VERSION=\\\"$$EXTENDED_VERSION\\\"
 
+# keep comments, as /* fall through */
+QMAKE_CXXFLAGS += -C
 QMAKE_CXXFLAGS += -g
 QMAKE_CXXFLAGS += -Wno-deprecated-copy
 
@@ -76,14 +104,14 @@ contains( CONFIG, PTU5 ) {
     CONFIG += link_pkgconfig
     lessThan(QT_MAJOR_VERSION, 5):   PKGCONFIG += qextserialport
     QMAKE_CXXFLAGS += -O2 -std=c++17   # for GCC >= 4.7
-    QMAKE_CXXFLAGS += -Wno-deprecated-copy
+    # QMAKE_CXXFLAGS += -Wno-deprecated-copy
     ARCH = PTU5
     DEFINES+=PTU5
 }
 contains( CONFIG, PTU5_YOCTO ) {
     greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
     QMAKE_CXXFLAGS += -std=c++17   # for GCC >= 4.7
-    QMAKE_CXXFLAGS += -Wno-deprecated-copy
+    # QMAKE_CXXFLAGS += -Wno-deprecated-copy
     PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
     DEFINES+=PTU5
@@ -97,7 +125,7 @@ contains( CONFIG, DesktopLinux ) {
     # QMAKE_CC = ccache $$QMAKE_CC
     # QMAKE_CXX = ccache $$QMAKE_CXX
     QMAKE_CXXFLAGS += -std=c++17
-    QMAKE_CXXFLAGS += -Wno-deprecated-copy
+    # QMAKE_CXXFLAGS += -Wno-deprecated-copy
     linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
     ARCH = DesktopLinux
     DEFINES+=DesktopLinux

git/git_client.cpp

@@ -302,7 +302,11 @@ std::optional<QString> GitClient::gitPull() {
             QString const s = c.getCommandResult().trimmed();
             if (!s.isEmpty()) {
                 QStringList lines = Update::split(s, '\n');
+                worker()->CONSOLE(lines) << Worker::UPDATE_STEP::UPDATE_REPOSITORY;
                 if (!lines.empty()) {
+                    static const QRegularExpression alreadyUpToDate("^\\s*Already\\s+up\\s+to\\s+date.*$");
+                    if (std::none_of(lines.cbegin(), lines.cend(),
+                        [](QString const &s) { return s.contains(alreadyUpToDate); })) {
                         int zoneNr = Utils::read1stLineOfFile("/mnt/system_data/zone_nr");
                         m_branchName = (zoneNr != 0) ? QString("zg1/zone%1").arg(zoneNr) : "master";
                         // lines can look like this:
@@ -321,36 +325,38 @@ std::optional<QString> GitClient::gitPull() {
                                 QRegularExpressionMatch match = re.match(lines.at(i));
                                 if (match.hasMatch()) {
                                     if (re.captureCount() == 3) { // start with full match (0), then the other 3 matches
-                                    return match.captured(2);
+                                        QString const matchCaptured = match.captured(2);
+                                        worker()->CONSOLE(QStringList(matchCaptured)) << Worker::UPDATE_STEP::UPDATE_REPOSITORY;
+                                        return matchCaptured;
                                     } else {
-                                    emit m_worker->showErrorMessage("git pull",
-                                        QString("(wrong cap-count (%1)").arg(re.captureCount()));
+                                        QStringList lst(QString("(wrong capture count (%1)").arg(re.captureCount()));
+                                        worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
                                     }
                                 } else {
-                                emit m_worker->showErrorMessage("git pull",
-                                    "no regex-match for commits");
-                                Utils::printCriticalErrorMsg("NO REGEX MATCH FOR COMMITS");
+                                    QStringList lst("no regex-match for commits");
+                                    worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
                                 }
                             }
                         }
                         if (!found) {
-                        emit m_worker->showErrorMessage("git pull",
-                            QString("unkown branch name ") + m_branchName);
-                        Utils::printCriticalErrorMsg("UNKNOWN BRANCH NAME " + m_branchName);
+                            QStringList lst(QString("unknown branch name ") + m_branchName);
+                            worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
                         }
                     } else {
-                    emit m_worker->showErrorMessage("git pull",
-                        QString("wrong format for result of 'git pull' ") + s);
-                    Utils::printCriticalErrorMsg(QString("WRONG FORMAT FOR RESULT OF 'GIT FETCH' ") + s);
+                        return "Already up to date";
                     }
                 } else {
-                // emit m_worker->showErrorMessage("git fetch", "empty result for 'git fetch'");
-                Utils::printInfoMsg("EMPTY RESULT FOR 'GIT PULL'");
+                    QStringList lst(QString("WRONG FORMAT FOR RESULT OF 'GIT PULL' ") + s);
+                    worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
+                }
+            } else {
+                QStringList lst("EMPTY RESULT FOR 'GIT PULL'");
+                worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
             }
         }
     } else {
-        emit m_worker->showErrorMessage("git pull", QString("repository ") + m_customerRepository + " does not exist");
-        Utils::printCriticalErrorMsg(QString("REPOSITORY ") + m_customerRepository + " DOES NOT EXIST");
+        QStringList lst(QString("REPOSITORY ") + m_customerRepository + " DOES NOT EXIST");
+        worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
     }
     return std::nullopt;
 }

git/git_client.h

@@ -43,6 +43,9 @@ class GitClient : public QObject {
 
     bool gitCloneAndCheckoutBranch();
 
+    Worker *worker() { return m_worker; }
+    Worker const *worker() const { return m_worker; }
+
     std::optional<QString> gitPull();
     std::optional<QStringList> gitDiff(QString const &commit);
     std::optional<QStringList> gitMerge();

ismas/ismas_client.cpp

@@ -56,7 +56,7 @@ void IsmasClient::printDebugMessage(int port,
                                     QString const &clientIP,
                                     int clientPort,
                                     QString const &message) {
-#if 1
+#if 0
     Q_UNUSED(port);
     Q_UNUSED(clientIP);
     Q_UNUSED(clientPort);
@@ -77,7 +77,7 @@ void IsmasClient::printInfoMessage(int port,
                                    QString const &clientIP,
                                    int clientPort,
                                    QString const &message) {
-#if 1
+#if 0
     Q_UNUSED(port);
     Q_UNUSED(clientIP);
     Q_UNUSED(clientPort);
@@ -315,7 +315,7 @@ IsmasClient::sendRequestReceiveResponse(int port, QString const &request) {
             }
         }
 
-        printInfoMessage(port, clientIP, clientPort, QString("MESSAGE RECEIVED ") + buf);
+        // printInfoMessage(port, clientIP, clientPort, QString("MESSAGE RECEIVED ") + buf);
         QString response(buf);
 
         if (int idx = response.indexOf("{\"error\":\"ISMAS is offline\"}")) {

mainwindow.cpp

@@ -157,7 +157,7 @@ MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *paren
     connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString)));
     connect(m_worker, SIGNAL(showErrorMessage(QStringList)),this, SLOT(onShowErrorMessage(QStringList)));
     connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString)));
-    connect(m_worker, SIGNAL(replaceLast(QStringList)),this,SLOT(onReplaceLast(QStringList)));
+    connect(m_worker, SIGNAL(replaceLast(QString,QString)),this,SLOT(onReplaceLast(QString,QString)));
     connect(m_worker, SIGNAL(replaceLast(QStringList,QString)),this, SLOT(onReplaceLast(QStringList,QString)));
 }
 
@@ -329,8 +329,18 @@ void MainWindow::onRestartExitTimer() {
 
 void MainWindow::onQuit() {
     m_exitTimer->stop();
-    qCritical() << QString("ON QUIT: EXIT CODE %1").arg(m_worker->returnCode());
-    qApp->exit(m_worker->returnCode());
+    int errorCode = 0;
+
+    qCritical()
+        << QString("ON QUIT: CURRENT STEP %1")
+            .arg(m_worker->getSmap()[m_worker->currentStep()]);
+
+    // TODO: replace SEND_LAST_VERSION with UPDATE_SUCCEEDED
+    if (m_worker->currentStep() != Worker::UPDATE_STEP::SEND_LAST_VERSION) {
+        errorCode = -1;
+    }
+    qCritical() << QString("ON QUIT: EXIT CODE %1").arg(errorCode);
+    qApp->exit(errorCode);
 }
 
 void MainWindow::scrollDownTextEdit() {

worker.cpp

@@ -16,6 +16,7 @@
 #include <QPushButton>
 #include <QJsonParseError>
 #include <Qt>
+#include <QScopedPointer>
 
 #include "message_handler.h"
 #include "plugins/interfaces.h"
@@ -24,11 +25,9 @@
 #include "mainwindow.h"
 #include "utils.h"
 
-
-#define FUNC_NAME QString(__func__).toUpper()
-
 QString const Worker::UPDATE_STEP_OK     (   " [  ok]");
 QString const Worker::UPDATE_STEP_DONE   (   " [done]");
+QString const Worker::UPDATE_STEP_WRONG   (  "[WRONG]");
 QString const Worker::UPDATE_STEP_FAIL   (   " [FAIL]");
 QString const Worker::UPDATE_STEP_SUCCESS(" [SUCCESS]");
 
@@ -52,15 +51,36 @@ const QMap<UPDATE_STEP, const char*> Worker::smap (
         INSERT_ELEMENT(UPDATE_STEP::CHECKOUT_REPOSITORY_SUCCESS),
         INSERT_ELEMENT(UPDATE_STEP::CHECKOUT_REPOSITORY_FAILURE),
         INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER),
+        INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_WRONG_VALUE),
         INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS),
         INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE),
+        INSERT_ELEMENT(UPDATE_STEP::INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER),
+        INSERT_ELEMENT(UPDATE_STEP::INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER),
+        INSERT_ELEMENT(UPDATE_STEP::CHECKOUT_BRANCH),
+        INSERT_ELEMENT(UPDATE_STEP::CHECKOUT_BRANCH_SUCCESS),
+        INSERT_ELEMENT(UPDATE_STEP::CHECKOUT_BRANCH_FAILURE),
         INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY),
         INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS),
         INSERT_ELEMENT(UPDATE_STEP::UPDATE_REPOSITORY_FAILURE),
         INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES),
         INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS),
         INSERT_ELEMENT(UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE),
+        INSERT_ELEMENT(UPDATE_STEP::FILES_TO_UPDATE),
         INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES),
+        INSERT_ELEMENT(UPDATE_STEP::FILES_TO_DOWNLOAD),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMANDS),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_1),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_2),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_3),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_4),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_5),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_6),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_7),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_8),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_9),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_LAST),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_SUCCESS),
+        INSERT_ELEMENT(UPDATE_STEP::EXEC_OPKG_COMMAND_FAILURE),
         INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE),
         INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS),
         INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE),
@@ -78,6 +98,7 @@ const QMap<UPDATE_STEP, const char*> Worker::smap (
         INSERT_ELEMENT(UPDATE_STEP::SEND_LAST_VERSION),
         INSERT_ELEMENT(UPDATE_STEP::UPDATE_SUCCEEDED),
         INSERT_ELEMENT(UPDATE_STEP::UPDATE_FAILED),
+        INSERT_ELEMENT(UPDATE_STEP::UPDATE_ACTIVATED),
         INSERT_ELEMENT(UPDATE_STEP::FINISHED),
         INSERT_ELEMENT(UPDATE_STEP::DEBUG),
         INSERT_ELEMENT(UPDATE_STEP::ERROR)
@@ -126,7 +147,6 @@ Worker::Worker(int customerNr,
   , m_waitForNewUpdates(this)
   , m_filesToUpdate()
   , m_updateProcessRunning(true)
-  , m_returnCode(0)
   , m_mainWindow(nullptr) /* contains plugin */
   //, m_withoutIsmasDirectPort(true) /* useful for testing */ {
   , m_withoutIsmasDirectPort(false) /* useful for testing */ {
@@ -137,9 +157,7 @@ Worker::Worker(int customerNr,
     this->setObjectName("worker-object");
     QDir::setCurrent(m_workingDirectory);
 
-    if (std::optional<QString> v = getApismVersion()) {
-        m_apismVersion = v.value();
-    }
+    m_apismVersion = getAPISMYoctoVersion();
 
     this->moveToThread(&m_workerThread);
     m_workerThread.start();
@@ -217,19 +235,23 @@ bool Worker::isRepositoryCorrupted() {
 bool Worker::repairCorruptedRepository() {
     QDir customerRepository(m_customerRepository);
     if (!customerRepository.removeRecursively()) {
+
         Utils::printCriticalErrorMsg("ERROR REMOVING CORR. CUST-REPOSITORY");
-        m_updateStatus = UpdateStatus(UPDATE_STATUS::REMOVE_GIT_REPOSITORY_FAILED,
-                            QString("REMOVAL OF GIT-REPOSITORY %1 FAILED").arg(m_customerRepository));
-        IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-            QString("#M=APISM#C=CMD_EVENT#J=") +
-                m_ismasClient.sanityCheckFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
-                                                m_updateStatus.m_statusDescription));
-        emit showErrorMessage("apism sanity check", m_updateStatus.m_statusDescription);
+
+        //m_updateStatus = UpdateStatus(UPDATE_STATUS::REMOVE_GIT_REPOSITORY_FAILED,
+        //                    QString("REMOVAL OF GIT-REPOSITORY %1 FAILED").arg(m_customerRepository));
+        //IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+        //    QString("#M=APISM#C=CMD_EVENT#J=") +
+        //        m_ismasClient.sanityCheckFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
+        //                                        m_updateStatus.m_statusDescription));
+        //emit showErrorMessage("apism sanity check", m_updateStatus.m_statusDescription);
+
         return false;
     }
     return true;
 }
 
+#if 0
 int Worker::sendCloneAndCheckoutFailure() {
     m_updateStatus = UpdateStatus(UPDATE_STATUS::GIT_CLONE_AND_CHECKOUT_FAILURE,
                           QString("CLONE OR CHECKOUT FAILED: ") + m_customerRepository);
@@ -343,20 +365,21 @@ int Worker::sendFoundFilesToUpdateSuccess() {
 }
 
 int Worker::sendUpdateSucceededAndActivated() {
-    IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-        QString("#M=APISM#C=CMD_EVENT#J=") +
-            m_ismasClient.updateOfPSASucceeded(""));
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::UPDATE_SUCCEEDED));
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::UPDATE_ACTIVATED));
+    //IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+    //    QString("#M=APISM#C=CMD_EVENT#J=") +
+    //        m_ismasClient.updateOfPSASucceeded(""));
 
     //m_ismasClient.setProgressInPercent(100);
 
     // mark update as activated -> this resets the WAIT button
-    IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-        QString("#M=APISM#C=CMD_EVENT#J=") +
-            m_ismasClient.updateOfPSAActivated());
+    //IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+    //    QString("#M=APISM#C=CMD_EVENT#J=") +
+    //        m_ismasClient.updateOfPSAActivated());
 
     return UPDATE_SUCCESS_AND_ACTIVATED;
 }
-
 int Worker::sendFinalResult() {
     m_updateStatus = UpdateStatus(UPDATE_STATUS::UPDATE_PROCESS_SUCCESS,
                                   QString("Update process succeeded. Reset WAIT."));
@@ -369,49 +392,61 @@ int Worker::sendFinalResult() {
     return 0;
 }
 
+#endif
+
 void Worker::privateUpdate() {
     if (!m_mainWindow) {
         Utils::printCriticalErrorMsg("m_mainWindow NOT SET");
         return;
     }
 
+    QString func(__PRETTY_FUNCTION__);
+
     GUI() << (ISMAS() << (CONSOLE() << UPDATE_STEP::STARTED));
 
-    m_updateProcessRunning = true;
-    bool sentIsmasLastVersionNotification = false;
-
-    emit disableExit();
-
-    m_returnCode = -1;
-    startProgressLoop();
+    QScopedPointer<UpdateProcessRunning> upr(new UpdateProcessRunning(this));
 
     QDir customerRepository(m_customerRepository);
     QDir customerRepositoryEtc(QDir::cleanPath(m_customerRepository + QDir::separator() + "etc/"));
 
     CONSOLE() << UPDATE_STEP::CHECK_SANITY;
 
-    bool initialClone = false;      // the customer repository is cloned without
-                                    // checking the ISMAS-trigger (WAIT-)button.
-                                    // but if there was a sane repository
-                                    // available, then the trigger-button must
+    m_clone = false;
+    m_repairClone = false;
+    m_initialClone = false;
+                                    // the customer repository is cloned or
+                                    // repaired/re-cloned without checking the
+                                    // ISMAS-trigger (WAIT-)button.
+
+    // Case 1: no existing repository:
+
+                                    // if there was a sane repository
+                                    // available, then the trigger-button is
+                                    // checked:
+                                    // 1: trigger == WAIT: then
                                     // have been activated in ISMAS.
 
     bool continueUpdate = true;     // check if git-clone command has timed-out,
                                     // resulting in a corrupted git-repository, which
                                     // does not contain an ./etc-directory
-    if (isRepositoryCorrupted()) {
+
+    if (isRepositoryCorrupted()) {  // a not-existing repository is not meant
+                                    // to be corrupted
         CONSOLE() << UPDATE_STEP::CHECK_SANITY_FAILURE;
         if ((continueUpdate = repairCorruptedRepository()) == true) {
+            m_repairClone = true;
             CONSOLE() << UPDATE_STEP::REPOSITORY_RECOVERED_SUCCESS;
         } else {
-            CONSOLE() << UPDATE_STEP::REPOSITORY_RECOVERED_FAILURE;
+            ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::REPOSITORY_RECOVERED_FAILURE));
+            return;
         }
-    } else {
+    }
+
     CONSOLE() << UPDATE_STEP::CHECK_SANITY_SUCCESS;
-    }
 
     if (continueUpdate) {
         if ((continueUpdate = customerRepository.exists()) == false) {
+            m_initialClone = (m_repairClone == false);
             GUI() << (CONSOLE() << UPDATE_STEP::CLONE_REPOSITORY);
             for (int i = 0; i < 5; ++i) {   // try to checkout git repository
                 setProgress(i);             // and switch to branch
@@ -419,7 +454,7 @@ void Worker::privateUpdate() {
                     if (!isRepositoryCorrupted()) {
                         GUI() << (ISMAS() << (CONSOLE() << UPDATE_STEP::CLONE_REPOSITORY_SUCCESS));
                         continueUpdate = true;
-                        initialClone = true;
+                        m_clone = true;
                         break;
                     }
                 }
@@ -427,155 +462,127 @@ void Worker::privateUpdate() {
             }
 
             if (continueUpdate == false) {
-                GUI() << (CONSOLE() << UPDATE_STEP::CLONE_REPOSITORY_FAILURE);
+                GUI() << (ISMAS() << (CONSOLE() << UPDATE_STEP::CLONE_REPOSITORY_FAILURE));
+                return;
             }
 
+            Q_ASSERT_X(m_clone, (func + QString(":%1").arg(__LINE__)).toStdString().c_str(), "clone failed");
+
         } else {
 
+            Q_ASSERT_X(!m_clone, (func + QString(":%1").arg(__LINE__)).toStdString().c_str(), "m_clone not false");
+            Q_ASSERT_X(!m_initialClone, (func + QString(":%1").arg(__LINE__)).toStdString().c_str(), "m_initialClone not false");
+            Q_ASSERT_X(!m_repairClone, (func + QString(":%1").arg(__LINE__)).toStdString().c_str(), "m_repairClone not false");
+
             CONSOLE() << UPDATE_STEP::CHECK_REPOSITORY;
             if (isRepositoryCorrupted()) {
-                CONSOLE() << UPDATE_STEP::CHECK_REPOSITORY_FAILURE;
-                continueUpdate = false;
-            } else {
+                ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::CHECK_REPOSITORY_FAILURE));
+                return;
+            }
+        }
+    }
     CONSOLE() << UPDATE_STEP::CHECK_REPOSITORY_SUCCESS;
-            }
-        }
-    }                       // repository is existent and not corrupted.
-                            // check now if the ISMAS-trigger (WAIT-button)
-    if (continueUpdate) {   // is activated even in case of initial checkout
-        if ((continueUpdate = updateTriggerSet()) == false) {
-            // if (initialClone) {
+
+
+    ////////////////////////////////////////////////////////////////////////////
     //
-            //}
-            m_returnCode = sendIsmasTriggerFailure();
+    //                         CHECK UPDATE TRIGGER
+    //
+    ////////////////////////////////////////////////////////////////////////////
+    m_ismasTriggerActive = false;
+    if ((continueUpdate = updateTriggerSet()) == false) {
+        if (m_initialClone) {
+            GUI() << (ISMAS() << (CONSOLE() << UPDATE_STEP::INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER));
         }
-        if (continueUpdate) {   // configure customer environment -> checkout
-                                // branch in case someone has change the zone_nr
-            //qDebug() << UPDATE_STEP::CHECK_ISMAS_TRIGGER;
-            if ((continueUpdate = customerEnvironment(30)) == false) {
-                m_returnCode = sendCustomerEnvironmentConfigurationFailed();
-            }                   // determine which files has to be updated:
-        }                       // either sent to the hardware or rsynced with
-        if (continueUpdate) {   // the filesystem in case of tariff-files
-            //qDebug() << UPDATE_STEP::CHECKED_OUT_BRANCH;
-            if ((continueUpdate = filesToUpdate(50)) == false) {
-                m_returnCode = sendPullFailure();
-            }
-        }                       // send message to ISMAS about files which have
-        if (continueUpdate) {   // been checked in into git repository
-            //qDebug() << UPDATE_STEP::COMPUTE_FILES_TO_UPDATE;
-            sendFoundFilesToUpdateSuccess();
-            if ((continueUpdate = updateFiles(60)) == false) {
-                m_returnCode = sendFileUpdateFailure();
-            }
-        }
-        if (continueUpdate) {   // rsync (changed) files to file system
-            //qDebug() << UPDATE_STEP::DOWNLOAD_FILES_TO_UPDATE;
-            // TODO: rsync das komplette repository
-            if ((continueUpdate = syncCustomerRepositoryAndFS(70)) == false) {
-                m_returnCode = sendRsyncFailure();
-            }
-        }
-        if (continueUpdate) {   // send message to ISMAS about installed versions
-            //qDebug() << UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY;
-            if ((continueUpdate = sendIsmasLastVersionNotification(80)) == false) {
-                m_returnCode = sendLastVersionFailure();
-            }
-        }
-        if (continueUpdate) {   // future use: save logs of update process
-            sentIsmasLastVersionNotification = true;
-            if ((continueUpdate = saveLogFile(90)) == false) {
-                m_returnCode = sendSaveLogFilesFailure();
-            }
-        }                       // send message to ISMAS that update process
-        if (continueUpdate) {   // succeeded
-            //qDebug() << UPDATE_STEP::UPDATE_SUCCESS;
-            sendUpdateSucceededAndActivated();
-            m_returnCode = UPDATE_SUCCESS_AND_ACTIVATED;
-        }
-
-        setProgress(100);
-
-        if (m_returnCode != 0) {
-            stopProgressLoop();
-            emit appendText(QString("UPDATE "), UPDATE_STEP_FAIL);
+        return;
     } else {
-            emit appendText(QString("UPDATE "), UPDATE_STEP_SUCCESS);
-            sendFinalResult();
+        GUI() << (ISMAS() << (CONSOLE() << UPDATE_STEP::INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER));
     }
+    if (m_ismasTriggerActive == false) {// make it explicit again: only if the
+                                        // ismas trigger is active ('WAIT'),
+                                        // then proceed
+        return;
     }
+    GUI() << (ISMAS() << (CONSOLE() << UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS));
 
-    if (!sentIsmasLastVersionNotification) {
-        // try even if the backend is not connected
-        sendIsmasLastVersionNotification(100);
-    }
 
-    stopProgressLoop();
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    //                           CHECK-OUT BRANCH
+    //
+    ////////////////////////////////////////////////////////////////////////////
+    if ((continueUpdate = customerEnvironment()) == false) {
+        return;
+    }
+    CONSOLE() << UPDATE_STEP::CHECKOUT_BRANCH_SUCCESS;
 
-    m_updateProcessRunning = false;
-    emit enableExit();
-    emit restartExitTimer();
-}
 
-std::optional<QString> Worker::getApismVersion() {
-    for (int repeat = 0; repeat < 10; ++repeat) {
-        qInfo() << "REPEAT" << repeat << "In getApismVersion() -> #M=APISM#C=REQ_SELF#J={}";
-        std::optional<QString> result
-            = IsmasClient::sendRequestReceiveResponse(
-                IsmasClient::APISM::DIRECT_PORT, "#M=APISM#C=REQ_SELF#J={}");
-        if (result) {
-            QString msg  = result.value();
-            qInfo() << "In getApismVersion() -> APISM response" << msg;
-            QJsonParseError parseError;
-            QJsonDocument document(QJsonDocument::fromJson(msg.toUtf8(), &parseError));
-            if (parseError.error != QJsonParseError::NoError) {
-                qCritical() << "(1) INVALID JSON MSG: PARSING FAILED (msg=" << msg << "):"
-                            << parseError.error << parseError.errorString();
-                m_updateStatus = UpdateStatus(UPDATE_STATUS::JSON_PARSE_FAILURE,
-                                              QString("(2) INVALID JSON %1 %2 %3")
-                                                .arg(msg)
-                                                .arg(parseError.error)
-                                                .arg(parseError.errorString()));
-                IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                    QString("#M=APISM#C=CMD_EVENT#J=") +
-                        m_ismasClient.jsonParseFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
-                                                      m_updateStatus.m_statusDescription));
-                return std::nullopt;
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    //               COMPUTE CHANGED FILES OF CUSTOMER REPOSITORY
+    //
+    ////////////////////////////////////////////////////////////////////////////
+    if ((continueUpdate = filesToUpdate()) == false) {
+        return;
     }
-            if (!document.isObject()) {
-                qCritical() << "FILE IS NOT A JSON OBJECT!";
-                m_updateStatus = UpdateStatus(UPDATE_STATUS::JSON_PARSE_FAILURE,
-                                              QString("NOT A JSON-OBJECT %1").arg(msg));
-                IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                    QString("#M=APISM#C=CMD_EVENT#J=") +
-                        m_ismasClient.jsonParseFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
-                                                      m_updateStatus.m_statusDescription));
-                return std::nullopt;
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS));
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    //                  UPDATE THE PSA USING THE CHANGED FILES
+    //
+    ////////////////////////////////////////////////////////////////////////////
+    if ((continueUpdate = updateFiles()) == false) {
+        return;
     }
-            QJsonObject obj = document.object();
-            QStringList keys = obj.keys().filter("CMD_GET_APISMSTATUS_RESPONSE");
-            if (keys.size() != 1) {
-                m_updateStatus = UpdateStatus(UPDATE_STATUS::BACKEND_CHECK_FAILURE,
-                                    "CMD_GET_APISMSTATUS_RESPONSE KEY NOT AVAILABLE");
-                IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                    QString("#M=APISM#C=CMD_EVENT#J=") +
-                        m_ismasClient.sanityCheckFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
-                                                        m_updateStatus.m_statusDescription));
-                emit showErrorMessage("apism response", m_updateStatus.m_statusDescription);
-                return std::nullopt;
-            } else {
-                QString const key = keys.at(0);
-                QJsonValue v = obj.value(key);
-                return v.toObject().value("Version").toString();
+    GUI() << (CONSOLE() << UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS);
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    //             (R)SYNC THE REPOSITORY WITH THE LOCAL FILEYSTEM
+    //
+    ////////////////////////////////////////////////////////////////////////////
+    if ((continueUpdate = syncCustomerRepositoryAndFS()) == false) {
+        return;
     }
-        } else {
-            QThread::sleep(1);
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS));
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    //                            FUTURE: SAVE LOG FILES
+    //
+    ////////////////////////////////////////////////////////////////////////////
+    if ((continueUpdate = saveLogFile()) == false) {
+        return;
     }
-    }
-    return std::nullopt;
+    // ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::SAVE_LOGS_SUCCESS));
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    //                      FINAL MESSAGES (PART 1)
+    //
+    ////////////////////////////////////////////////////////////////////////////
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::UPDATE_SUCCEEDED));
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::UPDATE_ACTIVATED));
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::FINISHED));
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    //                 FINAL MESSAGES (PART 2): SEND-LAST-VERSION
+    //                 (destructor of struct UpdateProcessRunning)
+    //
+    ////////////////////////////////////////////////////////////////////////////
 }
 
 bool Worker::updateTriggerSet() {
+    // repository is existent and not corrupted. check now if the ISMAS-trigger
+    // (WAIT-button) is activated even in case of initial checkout
+    static const QString func = "UPDATE-TRIGGER-SET";
 
     if (m_withoutIsmasDirectPort) { // useful for testing
         return true;
@@ -586,23 +593,22 @@ bool Worker::updateTriggerSet() {
     QString triggerValue("");
 
     for (int repeat = 1; repeat <= 100; ++repeat) {
-        CONSOLE(QStringList(FUNC_NAME) << QString("-> REPEAT=%1").arg(repeat)) << UPDATE_STEP::DEBUG;
 
         if (repeat > 1) {
             int const startMs = QTime::currentTime().msecsSinceStartOfDay();
             int const durationMs = QTime::currentTime().msecsSinceStartOfDay() - startMs;
             QString const &s = QString("elapsed: %1.%2s").arg(durationMs / 1000).arg(durationMs % 1000);
-            CONSOLE(QStringList(FUNC_NAME) << s) << UPDATE_STEP::DEBUG;
+            CONSOLE(QStringList(func) << s) << UPDATE_STEP::DEBUG;
         } else {
-            CONSOLE(QStringList(FUNC_NAME)) << UPDATE_STEP::DEBUG;
+            CONSOLE(QStringList(func) << QString("-> REPEAT=%1").arg(repeat)) << UPDATE_STEP::DEBUG;
         }
 
         if ((repeat % 10) == 0) {
-            CONSOLE(QStringList(FUNC_NAME) << "RESTART APISM") << UPDATE_STEP::DEBUG;
+            CONSOLE(QStringList(func) << "RESTART APISM") << UPDATE_STEP::DEBUG;
             Command c("systemctl restart apism");
             if (c.execute("/tmp")) {
                 QThread::sleep(20); // give APISM some time to reconnect
-                CONSOLE(QStringList(FUNC_NAME) << "RESTART APISM DONE") << UPDATE_STEP::DEBUG;
+                CONSOLE(QStringList(func) << "RESTART APISM DONE") << UPDATE_STEP::DEBUG;
             }
         }
 
@@ -611,21 +617,21 @@ bool Worker::updateTriggerSet() {
                     IsmasClient::APISM::DIRECT_PORT, "#M=APISM#C=REQ_ISMASPARAMETER#J={}")) {
 
             QString const &msg = QString("APISM RESPONSE(%1)=(").arg(repeat) + result.value() + ")";
-            CONSOLE(QStringList(FUNC_NAME) << msg) << UPDATE_STEP::DEBUG;
+            CONSOLE(QStringList(func) << msg) << UPDATE_STEP::DEBUG;
 
             QJsonParseError parseError;
-            QJsonDocument document(QJsonDocument::fromJson(msg.toUtf8(), &parseError));
+            QJsonDocument document(QJsonDocument::fromJson(result.value().toUtf8(), &parseError));
             if (parseError.error != QJsonParseError::NoError) {
-                QStringList const &lst
-                    = QStringList(QString("check update trigger")) << QString("invalid json ")
-                             + QString("INVALID JSON MSG: PARSING FAILED (msg=%1 %2 %3)")
-                                    .arg(msg).arg(parseError.error).arg(parseError.errorString()).mid(0, 20);
+                QStringList lst(QString("INVALID JSON MSG: PARSING FAILED (json=<START>%1<END> error=[%2] str=[%3] offset=[%4])")
+                                .arg(msg)
+                                .arg(parseError.error)
+                                .arg(parseError.errorString())
+                                .arg(parseError.offset));
                 GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                 break;
             }
             if (!document.isObject()) {
-                QStringList const &lst =
-                    QStringList(QString("check update trigger")) << QString("not a json-object ") + msg;
+                QStringList lst(QString("not a json-object %1").arg(result.value()));
                 GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                 break;
             }
@@ -634,7 +640,8 @@ bool Worker::updateTriggerSet() {
 
             // always look for an 'error' first
             if (obj.contains("error")) {
-                CONSOLE(QStringList(obj.value("error").toString())) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE;
+                QStringList lst(obj.value("error").toString());
+                CONSOLE(QStringList(lst)) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE;
                 QThread::sleep(6);
                 continue;
             }
@@ -649,33 +656,29 @@ bool Worker::updateTriggerSet() {
                         int const customerNr = obj.value("Custom_ID").toInt(-1);
                         int const machineNr = obj.value("Device_ID").toInt(-1);
                         if (customerNr != m_customerNr) {
-                            QStringList const &lst =
-                                QStringList(QString("check update trigger"))
-                                    << QString("CUSTOMER-NR (%1) != LOCAL CUSTOMER-NR (%2)")
-                                        .arg(customerNr).arg(m_customerNr);
+                            QStringList lst(QString("CUSTOMER-NR (%1) != LOCAL CUSTOMER-NR (%2)")
+                                            .arg(customerNr).arg(m_customerNr));
                             GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                             break;
                         }
                         if (machineNr != m_machineNr) {
-                            QStringList const &lst =
-                                QStringList(QString("check update trigger"))
-                                    << QString("MACHINE-NR (%1) != LOCAL MACHINE-NR (%2)")
-                                        .arg(machineNr).arg(m_machineNr);
+                            QStringList lst(QString("MACHINE-NR (%1) != LOCAL MACHINE-NR (%2)")
+                                                .arg(machineNr).arg(m_machineNr));
                             GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                             break;
                         }
                     } else {
-                        QStringList const lst("Dev_ID DOES NOT CONTAIN Custom_ID AND/OR Device_ID");
+                        QStringList lst("Dev_ID DOES NOT CONTAIN Custom_ID AND/OR Device_ID");
                         GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                         break;
                     }
                 } else {
-                    QStringList const lst("Dev_ID KEY NOT A JSON-OBJECT");
+                    QStringList lst("Dev_ID KEY NOT A JSON-OBJECT");
                     GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                     break;
                 }
             } else {
-                QStringList const lst("Dev_ID KEY NOT AVAILABLE");
+                QStringList lst("Dev_ID KEY NOT AVAILABLE");
                 GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                 break;
             }
@@ -686,157 +689,124 @@ bool Worker::updateTriggerSet() {
                     obj = v.toObject();
                     if (obj.contains("TRG")) {
                         if ((triggerValue = obj.value("TRG").toString()) == "WAIT") {
-                            GUI() << (ISMAS() << (CONSOLE() << UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS));
-                            return true;
+                            m_ismasTriggerActive = true;
+                            return m_ismasTriggerActive;
                         } else
                         if (QRegExp("\\s*").exactMatch(triggerValue)) { // check for whitespace
-                            QStringList const &lst =
-                                QStringList(QString("check update trigger")) << QString("empty update trigger");
+                            QStringList lst("empty update trigger");
+                            if (m_clone) {
+                                GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_WRONG_VALUE);
+                                                    // if the customer repository has just been cloned
+                                break;              // it is OK the ISMAS trigger might not be 'WAIT'
+                            } else {
                                 GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
+                            }
                             QThread::sleep(6);
                             continue;
                         } else {
                             // if the download-button once has the wrong value, it will never recover
-                            QStringList const &lst =
-                                QStringList(QString("check update trigger"))
-                                    << QString("TRIGGER-VALUE=<%1> NOT 'WAIT'").arg(triggerValue);
+                            if (m_clone) {
+                                GUI() << (CONSOLE() << UPDATE_STEP::CHECK_ISMAS_TRIGGER_WRONG_VALUE);
+                            } else {
+                                QStringList lst(QString("TRIGGER-VALUE=<%1> NOT 'WAIT'").arg(triggerValue));
+                                GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
+                            }
+                            break;
+                        }
+                    } else {
+                        QStringList lst("TRG key not available");
                         GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                         break;
                     }
                 } else {
-                        QStringList const &lst =
-                            QStringList(QString("check update trigger")) << QString("TRG key not available");
+                    QStringList lst("Fileupload not a json-object");
                     GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                     break;
                 }
             } else {
-                    QStringList const &lst =
-                        QStringList(QString("check update trigger")) << QString("Fileupload not a json-object");
+                QStringList lst(QString("Fileupload not available"));
                 GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
                 break;
             }
         } else {
-                QStringList const &lst =
-                    QStringList(QString("check update trigger")) << QString("Fileupload not available");
-                GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
-                break;
-            }
-        } else {
-            QStringList const &lst =
-                QStringList(QString("check update trigger")) << QString("no ISMAS response");
+            QStringList lst = QStringList(QString("no ISMAS response"));
             GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE);
             QThread::sleep(6);
         }
     }
 
+    if (m_initialClone == false) {
         if (!triggerValue.contains("WAIT", Qt::CaseInsensitive)) {
-        QStringList const &lst =
-            QStringList(QString("check update trigger"))
-                << QString("ISMAS_UPDATE-TRIGGER-NOT-SET-OR-WRONG: VALUE=(") + triggerValue + ")";
+            QStringList lst(QString("ISMAS_UPDATE-TRIGGER-NOT-SET-OR-WRONG: VALUE=(") + triggerValue + ")");
             ISMAS(lst) << (GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE));
         }
+    }
 
     return false;
 }
 
-bool Worker::customerEnvironment(int progress) {
-    emit appendText("\nPrepare customer environment ...");
+bool Worker::customerEnvironment() {
+    // configure customer environment -> checkout branch in case someone has
+    // changed the zone_nr
+
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::CHECKOUT_BRANCH));
+
     if (QDir(m_customerRepository).exists()) {
-        startProgressLoop();
-        // setProgress(m_mainWindow->progressValue()/10 + 11);
         if (m_gc.gitCheckoutBranch()) {
-            stopProgressLoop();
-            m_ismasClient.setProgressInPercent(progress);
-
-            m_updateStatus = UpdateStatus(UPDATE_STATUS::GIT_CHECKOUT_BRANCH,
-                                    QString("CHECKED-OUT BRANCH ") + m_gc.branchName());
-
-            IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                                    QString("#M=APISM#C=CMD_EVENT#J=") +
-                                        m_ismasClient.checkoutBranch(m_updateStatus.m_statusDescription, ""));
-
-            emit replaceLast("Prepare customer environment ...", UPDATE_STEP_DONE);
-            qInfo() << "PREPARE CUSTOMER ENVIRONMENT DONE";
             return true;
         } else {
-            stopProgressLoop();
-            m_ismasClient.setProgressInPercent(0);
-
-            emit showErrorMessage("cust-env",
-                                  QString("Checkout ") + m_customerRepository + " failed");
-            Utils::printCriticalErrorMsg(QString("CHECKOUT OF " + m_customerRepository + "FAILED"));
+            QStringList lst(QString("CHECKOUT OF " + m_customerRepository + "FAILED"));
+            ISMAS(lst) << (GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECKOUT_BRANCH_FAILURE));
         }
-    } else {
-        emit showErrorMessage("cust-env", m_customerRepository + " does not exist");
-        Utils::printCriticalErrorMsg(m_customerRepository + " DOES NOT EXIST");
+    } else {// cannot happen
+        QStringList lst(QString(m_customerRepository + " DOES NOT EXIST"));
+        ISMAS(lst) << (GUI(lst) << (CONSOLE(lst) << UPDATE_STEP::CHECKOUT_BRANCH_FAILURE));
     }
 
-    emit replaceLast("Prepare customer environment ...", UPDATE_STEP_FAIL);
     return false;
 }
 
-bool Worker::filesToUpdate(int progress) {
-    m_ismasClient.setProgressInPercent(progress);
+bool Worker::filesToUpdate() {
+    // determine which files has to be updated: either sent to the hardware or
+    // rsynced with the filesystem in case of tariff-files
 
-    emit appendText("\nFetch changes files ...");
-    startProgressLoop();
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::UPDATE_REPOSITORY));
 
     // always execute contents of opkg_commands-file
     m_filesToUpdate << "etc/psa_update/opkg_commands";
 
     if (std::optional<QString> changes = m_gc.gitPull()) {
-        m_updateStatus = UpdateStatus(UPDATE_STATUS::GIT_FETCH_UPDATES,
-                                        QString("FETCHING OF ") + m_customerRepositoryPath +
-                                        QString(" INTO ") + m_customerRepository);
-
+        if (!changes.value().contains("Already up to date")) {
             if (std::optional<QStringList> changedFileNames = m_gc.gitDiff(changes.value())) {
-            if (m_gc.gitPull()) {
-                emit replaceLast(QString("Fetch changes files ..."), UPDATE_STEP_DONE);
                 m_filesToUpdate << changedFileNames.value();
-            } else {
-                emit showErrorMessage("files to update", "pulling files failed");
-                Utils::printCriticalErrorMsg("PULLING FILES FAILED");
-
-                emit replaceLast(QString("Fetch changes files ..."), UPDATE_STEP_FAIL);
-                return false;
-            }
-        }
-
-        Utils::printInfoMsg("FILES-TO-UPDATE " + m_filesToUpdate.join(','));
-
                 m_filesToUpdate.removeDuplicates();
-        int const size = m_filesToUpdate.size();
-        if (size > 1) {
-            emit appendText(QString("Found %1 files to update :").arg(size), UPDATE_STEP_DONE);
-            for (int i = 0; i < size; ++i) {
-                emit appendText(QString("\n ") + m_filesToUpdate.at(i));
             }
+        }
+        GUI() << (CONSOLE(m_filesToUpdate) << UPDATE_STEP::FILES_TO_UPDATE);
     } else {
-            emit appendText("Found 1 file to update :", UPDATE_STEP_DONE);
-            emit appendText(QString("\n ") + m_filesToUpdate.at(0));
-        }
+        ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::UPDATE_REPOSITORY_FAILURE));
     }
 
     return true;
 }
 
-bool Worker::updateFiles(int percent) {
+bool Worker::updateFiles() {
     m_filesToDownload.clear();
     m_displayIndex = 0;
-    startProgressLoop();
+
+    GUI(m_filesToUpdate) << (CONSOLE(m_filesToUpdate) << UPDATE_STEP::APPLY_REPOSITORY_CHANGES);
+
     for (int i = 0; i < m_filesToUpdate.size(); ++i) {
         QString const fName = m_filesToUpdate.at(i);
-        Utils::printInfoMsg(QString("FNAME ") + fName);
-
         if (fName.contains("opkg_commands", Qt::CaseInsensitive)) {
-            emit appendText("\n( ) Update opkg pakets ...");
+            GUI() << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMANDS);
             // execute opkg commands
             if (QDir::setCurrent(m_customerRepository)) {
                 QFile f(fName);
                 if (f.exists()) {
                     if (f.open(QIODevice::ReadOnly)) {
                         QTextStream in(&f);
-                        QStringList opkgCommands;
+                        m_opkgCommands.clear();
                         bool executeOpkgCommandFailed = false;
                         while (!in.atEnd()) {
                             QString line = in.readLine();
@@ -849,31 +819,54 @@ bool Worker::updateFiles(int percent) {
                                 } else {
                                     QString cmd = "\n  " + opkgCommand;
                                     emit appendText(cmd);
-                                    opkgCommands << cmd;
+                                    m_opkgCommands << cmd;
 
-                                    m_ismasClient.setProgressInPercent(++percent);
-                                    m_updateStatus = UpdateStatus(UPDATE_STATUS::EXEC_OPKG_COMMAND,
-                                                        QString("EXEC OPKG-COMMAND ") + opkgCommand);
-                                    IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                                            QString("#M=APISM#C=CMD_EVENT#J=") +
-                                                m_ismasClient.execOpkgCommand(m_updateStatus.m_statusDescription, ""));
+                                    QStringList const opkgLst(opkgCommand);
+                                    QStringList const cmdLst(cmd);
+
+                                    switch(m_opkgCommands.size()) {
+                                    case 1:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_1));
+                                    break;
+                                    case 2:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_2));
+                                    break;
+                                    case 3:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_3));
+                                    break;
+                                    case 4:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_4));
+                                    break;
+                                    case 5:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_5));
+                                    break;
+                                    case 6:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_6));
+                                    break;
+                                    case 7:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_7));
+                                    break;
+                                    case 8:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_8));
+                                    break;
+                                    case 9:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_9));
+                                    break;
+                                    default:
+                                        ISMAS(opkgLst) << (GUI(cmdLst) << (CONSOLE() << UPDATE_STEP::EXEC_OPKG_COMMAND_LAST));
+                                    }
                                 }
                             }
                         }
                         f.close();
                         if (!executeOpkgCommandFailed) {
-                            if (opkgCommands.size() > 0) {
+                            if (m_opkgCommands.size() > 0) {
                                 m_displayIndex = 1;
-                                QString prepend = QString("(") + QString("%1").arg(m_displayIndex).rightJustified(3, ' ') + QString(")")
-                                                    + QString(" Update opkg pakets ... ");
-                                opkgCommands.prepend(prepend);
-                                emit replaceLast(opkgCommands, UPDATE_STEP_DONE);
+                                GUI() << UPDATE_STEP::EXEC_OPKG_COMMAND_SUCCESS;
                             }
                         } else {
                             m_displayIndex = 1;
-                            emit replaceLast(QString("(") + QString("%1").arg(m_displayIndex).rightJustified(3, ' ') + QString(")")
-                                          + QString(" Update opkg pakets ... "), UPDATE_STEP_FAIL);
-
+                            GUI() << UPDATE_STEP::EXEC_OPKG_COMMAND_FAILURE;
                             return false;
                         }
                     }
@@ -894,25 +887,24 @@ bool Worker::updateFiles(int percent) {
     }
 
     if (m_filesToDownload.size() > 0) {
-        Utils::printInfoMsg(QString("FILES_TO_DOWNLOAD_TO_PSA_HW ") + m_filesToDownload.join(','));
+        CONSOLE(m_filesToDownload) << UPDATE_STEP::FILES_TO_DOWNLOAD;
 
         Update *update = m_mainWindow->getUpdate();
         if (update) {
             return update->doUpdate(m_displayIndex, m_filesToDownload);
         } else {
-            Utils::printCriticalErrorMsg("UPDATE NOT SET");
+            CONSOLE(QStringList("UPDATE NOT SET")) << UPDATE_STEP::ERROR;
         }
     } else {
-        Utils::printCriticalErrorMsg("NO FILES_TO_DOWNLOAD_TO_PSA_HW");
+        CONSOLE(QStringList("NO FILES TO DOENLOAD TO PSA-HW")) << UPDATE_STEP::ERROR;
     }
 
     return true;
 }
 
-bool Worker::syncCustomerRepositoryAndFS(int progress) {
-    m_ismasClient.setProgressInPercent(progress);
-    // this step is currently needed only for updating tariff-files
-    emit appendText("\nSync customer environment with filesystem ...");
+bool Worker::syncCustomerRepositoryAndFS() {
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY));
+
     if (QDir(m_customerRepository).exists()) {
         if (QDir::setCurrent(m_customerRepository)) {
             Command md("bash");
@@ -950,6 +942,7 @@ bool Worker::syncCustomerRepositoryAndFS(int progress) {
                         QStringList result = c.getCommandResult().split('\n');
                         QString const &p1 = "send_files mapped ";
                         QString const &p2 = "of size";
+
                         for (int i = 0; i < result.size(); ++i) {
                             QString line = result.at(i);
                             qInfo() << line;
@@ -960,14 +953,16 @@ bool Worker::syncCustomerRepositoryAndFS(int progress) {
                             if (sendFilesAtPos != -1 && ofSizeAtPos != -1) {
                                 sendFilesAtPos += p1.length();
                                 QString const &s = line.mid(sendFilesAtPos, ofSizeAtPos - sendFilesAtPos).trimmed();
-                                m_updateStatus = UpdateStatus(UPDATE_STATUS::RSYNC_FILE_SUCCESS,
-                                    QString("RSYNC FILE ") + s.split("/").last() +
-                                            " LAST-COMMIT: " + m_gc.gitLastCommit(s));
-                                IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                                        QString("#M=APISM#C=CMD_EVENT#J=") +
-                                            m_ismasClient.rsyncFile(m_updateStatus.m_statusDescription, ""));
+
+                                //m_updateStatus = UpdateStatus(UPDATE_STATUS::RSYNC_FILE_SUCCESS,
+                                //    QString("RSYNC FILE ") + s.split("/").last() +
+                                //            " LAST-COMMIT: " + m_gc.gitLastCommit(s));
+                                //IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                                //        QString("#M=APISM#C=CMD_EVENT#J=") +
+                                //            m_ismasClient.rsyncFile(m_updateStatus.m_statusDescription, ""));
                             }
                         }
+
                     } else {
                         Utils::printCriticalErrorMsg(QString("CMD ") + cmd + " FAILED: "
                                                    + c.getCommandResult() + QString(" EXIT_CODE=(%1)").arg(c.exitCode()));
@@ -980,18 +975,17 @@ bool Worker::syncCustomerRepositoryAndFS(int progress) {
                 QDir dir1(QDir::cleanPath(m_customerRepository + QDir::separator() + "etc/psa_tariff"));
                 QDir dir2("/etc/psa_tariff");
                 if (Utils::sameFilesInDirs(dir1, dir2)) {
-                    emit replaceLast(QString("Sync customer environment with filesystem ..."), UPDATE_STEP_DONE);
+                    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS));
                     return true;
-                } else {
-                    // TODO: send message to ISMAS
                 }
             }
         }
     }
-    emit replaceLast(QString("Sync customer environment with filesystem ..."), UPDATE_STEP_FAIL);
+    ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE));
     return false;
 }
 
+#if 0
 bool Worker::sendIsmasLastVersionNotification(int progress) {
     m_ismasClient.setProgressInPercent(progress);
     IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
@@ -1000,11 +994,14 @@ bool Worker::sendIsmasLastVersionNotification(int progress) {
     emit appendText(QString("Send last version info "), UPDATE_STEP_DONE);
     return true;
 }
+#endif
 
-bool Worker::saveLogFile(int progress) {
-    m_ismasClient.setProgressInPercent(progress);
+bool Worker::saveLogFile() {
+    // ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::SAVE_LOGS));
+    // ISMAS() << (GUI() << (CONSOLE() << UPDATE_STEP::SAVE_LOGS_FAILURE));
     return true;
 }
+
 QString Worker::getOsVersion() const {
     QString const cmd = QString("echo -n $(cat /etc/os-release | head -n 1 | cut -d'\"' -f2 | tr -d '\"')");
     Command c("bash");
@@ -1025,6 +1022,17 @@ QString Worker::getATBUpdateToolYoctoVersion() {
     return "N/A";
 }
 
+QString Worker::getAPISMYoctoVersion() {
+    if (QFile::exists("/var/lib/opkg/status")) {
+        QString const cmd = QString("echo -n $(cat /var/lib/opkg/status | grep -A1 apism | tail -n 1 | cut -d':' -f2 | cut -d' ' -f2)");
+        Command c("bash");
+        if (c.execute("/tmp", QStringList() << "-c" << cmd)) {
+            return c.getCommandResult(); // 1.4.1.0-r4
+        }
+    }
+    return "N/A";
+}
+
 QString Worker::getATBUpdateToolYoctoInstallationStatus()  {
     if (QFile::exists("/var/lib/opkg/status")) {
         QString const cmd = QString("echo -n $(cat /var/lib/opkg/status | grep -A3 atbupdatetool | tail -n 1 | cut -d':' -f2 | cut -d' ' -f2,3,4)");
@@ -1036,6 +1044,16 @@ QString Worker::getATBUpdateToolYoctoInstallationStatus()  {
     return "N/A";
 }
 
+QString Worker::getAPISMYoctoInstallationStatus()  {
+    if (QFile::exists("/var/lib/opkg/status")) {
+        QString const cmd = QString("echo -n $(cat /var/lib/opkg/status | grep -A3 apism | tail -n 1 | cut -d':' -f2 | cut -d' ' -f2,3,4)");
+        Command c("bash");
+        if (c.execute("/tmp", QStringList() << "-c" << cmd)) {
+            return c.getCommandResult(); // 1.3.9+git0+226553a8ab-r0
+        }
+    }
+    return "N/A";
+}
 
 
 QString Worker::getATBQTVersion() const {
@@ -1191,9 +1209,7 @@ PSAInstalled Worker::getPSAInstalled() {
     psaInstalled.dc.gitLastCommit = "N/A";
     psaInstalled.dc.size = -1;
 
-    if (std::optional<QString> v = getApismVersion()) {
-        psaInstalled.sw.apismVersion = v.value();
-    }
+    psaInstalled.sw.apismVersion = getAPISMYoctoVersion();
     psaInstalled.sw.atbQTVersion = getATBQTVersion();
     psaInstalled.sw.atbUpdateToolVersion = m_atbUpdateToolVersion;
 

worker.h

@@ -26,94 +26,84 @@
 #define SERIAL_PORT "ttyUSB0"
 #endif
 
+#define _ISMAS_DONE         "U0001" // 100%
+#define _ISMAS_SET_WAIT_OK  "U0002" // empty WAIT-button ("")
+#define _ISMAS_FAILURE      "U0003" // FAIL
+#define _ISMAS_CONTINUE     "U0010" // %-values
+#define _ISMAS_RESET_WAIT   "ISMAS" // reset WAIT-button to "WAIT"
+
 #define _STARTED                                    (1)
 #define _CHECK_SANITY                               (2)
-#define _CHECK_SANITY_SUCCESS                   (3)
-#define _CHECK_SANITY_FAILURE                   (4)
-#define _REPOSITORY_RECOVERED_SUCCESS           (5)
-#define _REPOSITORY_RECOVERED_FAILURE           (6)
+#define _CHECK_SANITY_FAILURE                       (3)
+#define _CHECK_SANITY_SUCCESS                       (4)
+#define _REPOSITORY_RECOVERED_FAILURE               (5)
+#define _REPOSITORY_RECOVERED_SUCCESS               (6)
 #define _CHECK_REPOSITORY                           (7)
-#define _CHECK_REPOSITORY_SUCCESS               (8)
-#define _CHECK_REPOSITORY_FAILURE               (9)
+#define _CHECK_REPOSITORY_FAILURE                   (8)
+#define _CHECK_REPOSITORY_SUCCESS                   (9)
 #define _CLONE_REPOSITORY                           (10)
-#define _CLONE_REPOSITORY_SUCCESS               (11)
-#define _CLONE_REPOSITORY_FAILURE               (12)
+#define _CLONE_REPOSITORY_FAILURE                   (11)
+#define _CLONE_REPOSITORY_SUCCESS                   (12)
 #define _CHECKOUT_REPOSITORY                        (13)
-#define _CHECKOUT_REPOSITORY_SUCCESS            (14)
-#define _CHECKOUT_REPOSITORY_FAILURE            (15)
+#define _CHECKOUT_REPOSITORY_FAILURE                (14)
+#define _CHECKOUT_REPOSITORY_SUCCESS                (15)
+#define _INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER (16)
+#define _INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER    (17)
 #define _CHECK_ISMAS_TRIGGER                        (19)
-#define _CHECK_ISMAS_TRIGGER_SUCCESS            (23)
-#define _CHECK_ISMAS_TRIGGER_FAILURE            (24)
-#define _UPDATE_REPOSITORY                      (25)
-#define _UPDATE_REPOSITORY_SUCCESS              (28)
-#define _UPDATE_REPOSITORY_FAILURE              (29)
+#define _CHECK_ISMAS_TRIGGER_WRONG_VALUE            (20)
+#define _CHECK_ISMAS_TRIGGER_SUCCESS                (21)
+#define _CHECK_ISMAS_TRIGGER_FAILURE                (22)
+#define _CHECKOUT_BRANCH                            (23)
+#define _CHECKOUT_BRANCH_FAILURE                    (24)
+#define _CHECKOUT_BRANCH_SUCCESS                    (25)
+#define _UPDATE_REPOSITORY                          (26)
+#define _UPDATE_REPOSITORY_FAILURE                  (28)
+#define _UPDATE_REPOSITORY_SUCCESS                  (29)
 #define _CHECK_FOR_REPOSITORY_CHANGES               (30)
-#define _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS   (38)
-#define _CHECK_FOR_REPOSITORY_CHANGES_FAILURE   (39)
+#define _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS       (36)
+#define _FILES_TO_UPDATE                            (37)
+#define _CHECK_FOR_REPOSITORY_CHANGES_FAILURE       (38)
+#define _FILES_TO_DOWNLOAD                          (39)
 #define _APPLY_REPOSITORY_CHANGES                   (40)
-#define _DOWNLOAD_CONFIG_FILE                   (41)
+#define _EXEC_OPKG_COMMANDS                         (41)
+#define _EXEC_OPKG_COMMAND_1                        (42)
+#define _EXEC_OPKG_COMMAND_2                        (43)
+#define _EXEC_OPKG_COMMAND_3                        (44)
+#define _EXEC_OPKG_COMMAND_4                        (45)
+#define _EXEC_OPKG_COMMAND_5                        (46)
+#define _EXEC_OPKG_COMMAND_6                        (47)
+#define _EXEC_OPKG_COMMAND_7                        (48)
+#define _EXEC_OPKG_COMMAND_8                        (49)
+#define _EXEC_OPKG_COMMAND_9                        (50)
+#define _EXEC_OPKG_COMMAND_LAST                     (51)
+#define _EXEC_OPKG_COMMAND_FAILURE                  (52)
+#define _EXEC_OPKG_COMMAND_SUCCESS                  (53)
+#define _DOWNLOAD_CONFIG_FILE                       (54)
 #define _DOWNLOAD_CONFIG_FILE_SUCCESS               (63)
 #define _DOWNLOAD_CONFIG_FILE_FAILURE               (64)
 #define _DOWNLOAD_DEVICE_CONTROLLER                 (65)
 #define _DOWNLOAD_DEVICE_CONTROLLER_SUCCESS         (86)
 #define _DOWNLOAD_DEVICE_CONTROLLER_FAILURE         (87)
-#define _APPLY_REPOSITORY_CHANGES_SUCCESS       (88)
-#define _APPLY_REPOSITORY_CHANGES_FAILURE       (89)
+#define _APPLY_REPOSITORY_CHANGES_FAILURE           (88)
+#define _APPLY_REPOSITORY_CHANGES_SUCCESS           (89)
 #define _SYNC_CUSTOMER_REPOSITORY                   (90)
-#define _SYNC_CUSTOMER_REPOSITORY_SUCCESS       (91)
-#define _SYNC_CUSTOMER_REPOSITORY_FAILURE       (92)
-#define _SAVE_LOGS                              (94)
+#define _SYNC_CUSTOMER_REPOSITORY_FAILURE           (91)
+#define _SYNC_CUSTOMER_REPOSITORY_SUCCESS           (92)
+#define _SAVE_LOGS                                  (93)
+#define _SAVE_LOGS_FAILURE                          (94)
 #define _SAVE_LOGS_SUCCESS                          (95)
-#define _SAVE_LOGS_FAILURE                      (96)
-#define _SEND_LAST_VERSION                      (97)
-#define _UPDATE_SUCCEEDED                       (98)
-#define _UPDATE_FAILED                          (99)
+#define _SEND_LAST_VERSION                          (96)
+#define _UPDATE_SUCCEEDED                           (97)
+#define _UPDATE_FAILED                              (98)
+#define _UPDATE_ACTIVATED                           (99)
 #define _FINISHED                                   (100)
 #define _DEBUG                                      (1000)
 #define _ERROR                                      (1001)
 
-enum class UPDATE_STATUS : quint8 {
-    NOT_DEFINED,
-    ISMAS_WAIT_STATE_CHECK_PENDING,
-    ISMAS_WAIT_STATE_CHECK_FAILURE,
-    ISMAS_RESPONSE_RECEIVED,
-    BACKEND_CHECK,
-    BACKEND_CHECK_FAILURE,
-    BACKEND_NOT_CONNECTED,
-    ISMAS_UPDATE_TRIGGER_SET,
-    ISMAS_UPDATE_TRIGGER_NOT_SET_OR_WRONG,
-    GIT_CLONE_AND_CHECKOUT_SUCCESS,
-    GIT_CLONE_AND_CHECKOUT_FAILURE,
-    GIT_CHECKOUT_BRANCH,
-    GIT_CHECKOUT_BRANCH_FAILURE,
-    GIT_FETCH_UPDATES,
-    GIT_FETCH_UPDATES_REQUEST_FAILURE,
-    EXEC_OPKG_COMMAND,
-    EXEC_OPKG_COMMANDS,
-    RSYNC_UPDATES_FAILURE,
-    RSYNC_UPDATES_SUCCESS,
-    RSYNC_FILE_SUCCESS,
-    JSON_PARSE_FAILURE,
-    UPDATE_PROCESS_SUCCESS,
-    UPDATE_PROCESS_FAILURE,
-    ISMAS_SANITY_CHECK_OK,
-    ISMAS_UPDATE_TRIGGER_SET_FAILURE,
-    PSA_UPDATE_FILES_FAILED,
-    GIT_CHECK_FILES_TO_UPDATE_SUCCESS,
-    ISMAS_SEND_LAST_VERSION_FAILED,
-    SAVE_LOG_FILES_FAILED,
-    REMOVE_GIT_REPOSITORY_FAILED
-};
-
-struct UpdateStatus {
-    UPDATE_STATUS m_updateStatus;
-    QString m_statusDescription;
-
-    explicit UpdateStatus(UPDATE_STATUS s = UPDATE_STATUS::NOT_DEFINED,
-                          QString const &d = QString(""))
-        : m_updateStatus(s), m_statusDescription(d) {}
-};
-
+#define _SEND_LAST_VERSION_CORRECTION               (4)
+#define _UPDATE_SUCCEEDED_CORRECTION                (3)
+#define _UPDATE_FAILED_CORRECTION                   (2)
+#define _UPDATE_ACTIVATED_CORRECTION                (1)
 
 #define ISMAS_UPDATE_REQUESTS                       (10)
 #define CHECK_UPDATE_TRIGGER_SET                    "Check update trigger ..."
@@ -154,13 +144,14 @@ class Worker : public QObject {
     int m_ismasUpdateRequests;
     QTimer m_waitForNewUpdates;
 
-    UpdateStatus m_updateStatus;
-
     QStringList m_filesToUpdate;
     QStringList m_filesToDownload;
     bool m_updateProcessRunning;
     int m_displayIndex;
-    int m_returnCode;
+    bool m_clone = false;
+    bool m_initialClone = false;
+    bool m_repairClone = false;
+    bool m_ismasTriggerActive = false;
 
     MainWindow *m_mainWindow;
     bool m_withoutIsmasDirectPort;
@@ -193,17 +184,27 @@ class Worker : public QObject {
     int sendUpdateSucceededAndActivated();
     int sendFinalResult();
 
+    struct UpdateProcessRunning {
+        Worker *m_worker;
 
-    static constexpr const int UPDATE_SUCCESS_AND_ACTIVATED = 0;
-    static constexpr const int CLONE_AND_CHECKOUT_SUCCESS = 0;
-    static constexpr const int CLONE_AND_CHECKOUT_FAILURE = -3;
-    static constexpr const int ISMAS_TRIGGER_FAILURE = -5;
-    static constexpr const int ENVIRONMENT_CONFIG_FAILURE = -6;
-    static constexpr const int GIT_PULL_FAILURE = -7;
-    static constexpr const int UPDATE_FILES_FAILURE = -8;
-    static constexpr const int RSYNC_FAILURE = -9;
-    static constexpr const int SEND_LAST_VERSION_FAILURE = -10;
-    static constexpr const int SAVE_LOG_FILES_FAILURE = -11;
+        explicit UpdateProcessRunning(Worker *worker) : m_worker(worker) {
+            m_worker->m_updateProcessRunning = true;
+            emit m_worker->disableExit();
+            m_worker->startProgressLoop();
+        }
+
+        virtual ~UpdateProcessRunning() {
+            m_worker->ISMAS() << (m_worker->GUI() << (m_worker->CONSOLE()
+                              << UPDATE_STEP::SEND_LAST_VERSION));
+            m_worker->stopProgressLoop();
+
+            m_worker->m_updateProcessRunning = false;
+            emit m_worker->enableExit();
+            emit m_worker->restartExitTimer();
+        }
+    };
+
+    friend struct UpdateProcessRunning;
 
 public:
     enum class UPDATE_STEP {
@@ -223,15 +224,36 @@ public:
         CHECKOUT_REPOSITORY_SUCCESS = _CHECKOUT_REPOSITORY_SUCCESS,
         CHECKOUT_REPOSITORY_FAILURE = _CHECKOUT_REPOSITORY_FAILURE,
         CHECK_ISMAS_TRIGGER = _CHECK_ISMAS_TRIGGER,
+        CHECK_ISMAS_TRIGGER_WRONG_VALUE = _CHECK_ISMAS_TRIGGER_WRONG_VALUE,
         CHECK_ISMAS_TRIGGER_SUCCESS = _CHECK_ISMAS_TRIGGER_SUCCESS,
         CHECK_ISMAS_TRIGGER_FAILURE = _CHECK_ISMAS_TRIGGER_FAILURE,
+        INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER = _INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER,
+        INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER = _INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER,
+        CHECKOUT_BRANCH = _CHECKOUT_BRANCH,
+        CHECKOUT_BRANCH_SUCCESS = _CHECKOUT_BRANCH_SUCCESS,
+        CHECKOUT_BRANCH_FAILURE = _CHECKOUT_BRANCH_FAILURE,
         UPDATE_REPOSITORY = _UPDATE_REPOSITORY,
         UPDATE_REPOSITORY_SUCCESS = _UPDATE_REPOSITORY_SUCCESS,
         UPDATE_REPOSITORY_FAILURE = _UPDATE_REPOSITORY_FAILURE,
         CHECK_FOR_REPOSITORY_CHANGES = _CHECK_FOR_REPOSITORY_CHANGES,
         CHECK_FOR_REPOSITORY_CHANGES_SUCCESS = _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS,
         CHECK_FOR_REPOSITORY_CHANGES_FAILURE = _CHECK_FOR_REPOSITORY_CHANGES_FAILURE,
+        FILES_TO_UPDATE = _FILES_TO_UPDATE,
         APPLY_REPOSITORY_CHANGES = _APPLY_REPOSITORY_CHANGES,
+        FILES_TO_DOWNLOAD = _FILES_TO_DOWNLOAD,
+        EXEC_OPKG_COMMANDS = _EXEC_OPKG_COMMANDS,
+        EXEC_OPKG_COMMAND_1 = _EXEC_OPKG_COMMAND_1,
+        EXEC_OPKG_COMMAND_2 = _EXEC_OPKG_COMMAND_2,
+        EXEC_OPKG_COMMAND_3 = _EXEC_OPKG_COMMAND_3,
+        EXEC_OPKG_COMMAND_4 = _EXEC_OPKG_COMMAND_4,
+        EXEC_OPKG_COMMAND_5 = _EXEC_OPKG_COMMAND_5,
+        EXEC_OPKG_COMMAND_6 = _EXEC_OPKG_COMMAND_6,
+        EXEC_OPKG_COMMAND_7 = _EXEC_OPKG_COMMAND_7,
+        EXEC_OPKG_COMMAND_8 = _EXEC_OPKG_COMMAND_8,
+        EXEC_OPKG_COMMAND_9 = _EXEC_OPKG_COMMAND_9,
+        EXEC_OPKG_COMMAND_LAST = _EXEC_OPKG_COMMAND_LAST,
+        EXEC_OPKG_COMMAND_SUCCESS = _EXEC_OPKG_COMMAND_SUCCESS,
+        EXEC_OPKG_COMMAND_FAILURE = _EXEC_OPKG_COMMAND_FAILURE,
         DOWNLOAD_CONFIG_FILE = _DOWNLOAD_CONFIG_FILE,
         DOWNLOAD_CONFIG_FILE_SUCCESS = _DOWNLOAD_CONFIG_FILE_SUCCESS,
         DOWNLOAD_CONFIG_FILE_FAILURE = _DOWNLOAD_CONFIG_FILE_FAILURE,
@@ -248,6 +270,7 @@ public:
         SAVE_LOGS_FAILURE = _SAVE_LOGS_FAILURE,
         SEND_LAST_VERSION = _SEND_LAST_VERSION,
         UPDATE_SUCCEEDED = _UPDATE_SUCCEEDED,
+        UPDATE_ACTIVATED = _UPDATE_ACTIVATED,
         UPDATE_FAILED = _UPDATE_FAILED,
         FINISHED = _FINISHED,
         DEBUG = _DEBUG,
@@ -260,7 +283,9 @@ private:
     QStringList m_ismasMsg;
     UPDATE_STEP m_currentStep;
     static Worker *instance;
+    QStringList m_opkgCommands;
 
+public:
     QDebug CONSOLE(QStringList const &lst = QStringList()) {
         m_debugMsg = lst;
         return qDebug();
@@ -276,13 +301,19 @@ private:
         return this;
     }
 
-public:
+    static QMap<UPDATE_STEP, const char*> const &getSmap() {
+        return smap;
+    }
+
     static QString getATBUpdateToolYoctoVersion();
     static QString getATBUpdateToolYoctoInstallationStatus();
+    static QString getAPISMYoctoVersion();
+    static QString getAPISMYoctoInstallationStatus();
 
     static const QString UPDATE_STEP_OK;
     static const QString UPDATE_STEP_DONE;
     static const QString UPDATE_STEP_FAIL;
+    static const QString UPDATE_STEP_WRONG;
     static const QString UPDATE_STEP_SUCCESS;
 
     explicit Worker(int customerNr, // 281
@@ -309,7 +340,7 @@ public:
     IsmasClient const &getIsmasClient() const { return m_ismasClient; }
 
     bool updateProcessRunning() const { return m_updateProcessRunning; }
-    int returnCode() const { return m_returnCode; }
+    UPDATE_STEP currentStep() const { return m_currentStep; }
 
     int machineNr() const { return m_machineNr; }
     int customerNr() const { return m_customerNr; }
@@ -338,18 +369,16 @@ public slots:
 
 private slots:
     bool updateTriggerSet();
-    bool customerEnvironment(int progress);
-    bool filesToUpdate(int progress);
-    bool updateFiles(int percent);
-    bool syncCustomerRepositoryAndFS(int progress);
-    bool sendIsmasLastVersionNotification(int progress);
-    bool saveLogFile(int progress);
+    bool customerEnvironment();
+    bool filesToUpdate();
+    bool updateFiles();
+    bool syncCustomerRepositoryAndFS();
+    // bool sendIsmasLastVersionNotification(int progress);
+    bool saveLogFile();
 
 private:
     PSAInstalled getPSAInstalled();
     void privateUpdate();
-    std::optional<QString> getApismVersion();
-    void printProgress(UPDATE_STEP step);
 
     static const QMap<UPDATE_STEP, const char*> smap;
 
@@ -360,6 +389,7 @@ private:
         }
 
         Worker::instance->m_currentStep = step;
+        QStringList lst = QStringList(smap[step]);
 
         switch (step) {
         case UPDATE_STEP::STARTED: {
@@ -436,14 +466,34 @@ private:
         case UPDATE_STEP::CHECKOUT_REPOSITORY_FAILURE:
         break;
         case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
-            Utils::printUpdateStatusMsg(
-                debug,
-                QStringList(smap[step])
-                    << QString("CHECK ISMAS-TRIGGER-STATUS..."));
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
         break;
         case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
         break;
-        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_WRONG_VALUE:
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE: {
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
+        } break;
+        case UPDATE_STEP::INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER:
+        break;
+        case UPDATE_STEP::INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER:
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH:
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH_SUCCESS:
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH_FAILURE:
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
         break;
         case UPDATE_STEP::UPDATE_REPOSITORY:
         break;
@@ -457,7 +507,42 @@ private:
         break;
         case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
         break;
-        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
+        case UPDATE_STEP::FILES_TO_UPDATE:
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES: {
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
+        } break;
+        case UPDATE_STEP::FILES_TO_DOWNLOAD:
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMANDS:
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_1:
+            __attribute__((fallthrough));
+            // [[fallthrough]] -> c++17 -> unknown for clang
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_2:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_3:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_4:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_5:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_6:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_7:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_8:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_9:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_LAST:
+            lst << instance->m_debugMsg;
+            Utils::printUpdateStatusMsg(debug, lst);
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_SUCCESS:
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_FAILURE:
         break;
         case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
         break;
@@ -488,32 +573,42 @@ private:
         case UPDATE_STEP::SAVE_LOGS_FAILURE:
         break;
         case UPDATE_STEP::SEND_LAST_VERSION:
+            // SEND_LAST_VERSION_CORRECTION
         break;
         case UPDATE_STEP::UPDATE_SUCCEEDED:
         break;
+        case UPDATE_STEP::UPDATE_ACTIVATED:
+        break;
         case UPDATE_STEP::UPDATE_FAILED:
         break;
         case UPDATE_STEP::FINISHED:
         break;
-        case UPDATE_STEP::DEBUG:
-            Utils::printUpdateStatusMsg(
-                debug, QStringList(smap[step]) << instance->m_debugMsg);
-        break;
+        case UPDATE_STEP::DEBUG: {
+            lst << instance->m_debugMsg;
+            qCritical() << __LINE__ << lst;
+            Utils::printUpdateStatusMsg(debug, lst);
+        } break;
         case UPDATE_STEP::ERROR:
             //Utils::printUpdateStatusMsg(
             //    debug, QStringList(smap[step]) << instance->m_errorMsg);
         break;
         }
 
+        instance->m_debugMsg.clear();
+
         return step;
     }
 
+    // ISMAS()
     friend UPDATE_STEP operator<<(IsmasClient &ismasClient, UPDATE_STEP step) {
 
         if (!Worker::instance) {
             return step;
         }
 
+        Worker::instance->m_currentStep = step;
+        QStringList lst = QStringList(smap[step]);
+
         switch (step) {
         case UPDATE_STEP::STARTED: {
             ismasClient.setProgressInPercent(_STARTED);
@@ -570,8 +665,8 @@ private:
                             .arg(instance->m_customerRepository)
                             .arg(instance->m_gc.branchName()).toStdString().c_str(),
                         "");
-            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                                                   ismasUpdateNews);
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
         } break;
         case UPDATE_STEP::CHECKOUT_REPOSITORY:
             ismasClient.setProgressInPercent(_CHECKOUT_REPOSITORY);
@@ -588,7 +683,6 @@ private:
         case UPDATE_STEP::CHECKOUT_REPOSITORY_FAILURE:
             ismasClient.setProgressInPercent(_CHECKOUT_REPOSITORY_FAILURE);
         break;
-        break;
         case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
             ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER);
         break;
@@ -598,12 +692,60 @@ private:
                 QString("#M=APISM#C=CMD_EVENT#J=") +
                          ismasClient.updateTriggerSet("ISMAS TRIGGER SET", ""));
         break;
-        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
-            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_FAILURE);
-            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                QString("#M=APISM#C=CMD_EVENT#J=") +
-                    ismasClient.errorUpdateTrigger(instance->m_ismasMsg.join(' '), ""));
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_WRONG_VALUE:
+            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_WRONG_VALUE);
         break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE: {
+            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_FAILURE);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0003",
+                        _CHECK_ISMAS_TRIGGER_FAILURE,
+                        IsmasClient::RESULT_CODE::INSTALL_ERROR,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
+        case UPDATE_STEP::INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER:
+            ismasClient.setProgressInPercent(_INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER);
+        break;
+        case UPDATE_STEP::INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER:
+            ismasClient.setProgressInPercent(_INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER);
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH:
+            ismasClient.setProgressInPercent(_CHECKOUT_BRANCH);
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH_SUCCESS: {
+            ismasClient.setProgressInPercent(_CHECKOUT_BRANCH_SUCCESS);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0010",
+                        _CHECKOUT_BRANCH_SUCCESS,
+                        IsmasClient::RESULT_CODE::SUCCESS,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
+        case UPDATE_STEP::CHECKOUT_BRANCH_FAILURE: {
+            ismasClient.setProgressInPercent(_CHECKOUT_BRANCH_FAILURE);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0003",
+                        _CHECKOUT_BRANCH_FAILURE,
+                        IsmasClient::RESULT_CODE::INSTALL_ERROR,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
         case UPDATE_STEP::UPDATE_REPOSITORY:
             ismasClient.setProgressInPercent(_UPDATE_REPOSITORY);
         break;
@@ -622,9 +764,139 @@ private:
         case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
             ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES_FAILURE);
         break;
+        case UPDATE_STEP::FILES_TO_UPDATE:
+            ismasClient.setProgressInPercent(_FILES_TO_UPDATE);
+        break;
         case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
             ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES);
         break;
+        case UPDATE_STEP::FILES_TO_DOWNLOAD:
+            ismasClient.setProgressInPercent(_FILES_TO_DOWNLOAD);
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMANDS:
+            ismasClient.setProgressInPercent(_EXEC_OPKG_COMMANDS);
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_1:
+            ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_1);
+            __attribute__((fallthrough)); // [[fallthrough]]; -> c++17, unknown to clang
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_2: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_2);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_3: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_3);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_4: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_3: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_4);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_5: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_3: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_4: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_5);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_6: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_3: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_4: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_5: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_6);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_7: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_3: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_4: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_5: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_6: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_7);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_8: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_3: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_4: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_5: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_6: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_7: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_8);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_9: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_3: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_4: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_5: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_6: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_7: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_8: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_9);
+            } __attribute__((fallthrough));
+        }
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_LAST: {
+            switch(step) {
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_1: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_2: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_3: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_4: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_5: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_6: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_7: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_8: break;
+            case UPDATE_STEP::EXEC_OPKG_COMMAND_9: break;
+            default: ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_LAST);
+            }
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        _ISMAS_CONTINUE,
+                        ismasClient.getProgressInPercent(),
+                        IsmasClient::RESULT_CODE::SUCCESS,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_SUCCESS: {
+            ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_SUCCESS);
+        } break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_FAILURE: {
+            ismasClient.setProgressInPercent(_EXEC_OPKG_COMMAND_FAILURE);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        _ISMAS_FAILURE,
+                        ismasClient.getProgressInPercent(),
+                        IsmasClient::RESULT_CODE::INSTALL_ERROR,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
         case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
             ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE);
         break;
@@ -667,15 +939,54 @@ private:
         case UPDATE_STEP::SAVE_LOGS_FAILURE:
             ismasClient.setProgressInPercent(_SAVE_LOGS_FAILURE);
         break;
-        case UPDATE_STEP::SEND_LAST_VERSION:
-            ismasClient.setProgressInPercent(_SEND_LAST_VERSION);
-        break;
-        case UPDATE_STEP::UPDATE_SUCCEEDED:
-            ismasClient.setProgressInPercent(_UPDATE_SUCCEEDED);
-        break;
-        case UPDATE_STEP::UPDATE_FAILED:
+        case UPDATE_STEP::SEND_LAST_VERSION: {
+            ismasClient.setProgressInPercent(_SEND_LAST_VERSION + _SEND_LAST_VERSION_CORRECTION);
+            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                QString("#M=APISM#C=CMD_SENDVERSION#J=") +
+                    ismasClient.updateOfPSASendVersion(instance->getPSAInstalled()));
+        } break;
+        case UPDATE_STEP::UPDATE_SUCCEEDED: {
+            ismasClient.setProgressInPercent(_UPDATE_SUCCEEDED + _UPDATE_SUCCEEDED_CORRECTION);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0001", // WAIT-button set to 100%
+                        ismasClient.getProgressInPercent(),
+                        IsmasClient::RESULT_CODE::SUCCESS,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
+        case UPDATE_STEP::UPDATE_ACTIVATED: {
+            ismasClient.setProgressInPercent(_UPDATE_ACTIVATED + _UPDATE_ACTIVATED_CORRECTION);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0002", // reset WAIT-button to "" (empty string)
+                        ismasClient.getProgressInPercent(),
+                        IsmasClient::RESULT_CODE::SUCCESS,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
+        case UPDATE_STEP::UPDATE_FAILED: {
             ismasClient.setProgressInPercent(_UPDATE_FAILED);
-        break;
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0003",
+                        ismasClient.getProgressInPercent(),
+                        IsmasClient::RESULT_CODE::INSTALL_ERROR,
+                        smap[step],
+                        instance->m_ismasMsg.join(' ').toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(
+                IsmasClient::APISM::DB_PORT, ismasUpdateNews);
+        } break;
         case UPDATE_STEP::FINISHED:
             ismasClient.setProgressInPercent(_FINISHED);
         break;
@@ -685,10 +996,19 @@ private:
         break;
         }
 
+        instance->m_ismasMsg.clear();
+
         return step;
     }
 
+    // GUI()
     friend UPDATE_STEP operator<<(Worker *worker, UPDATE_STEP step) {
+        if (!Worker::instance) {
+            return step;
+        }
+
+        Worker::instance->m_currentStep = step;
+
         switch (step) {
         case UPDATE_STEP::STARTED:
         break;
@@ -731,15 +1051,36 @@ private:
         break;
         case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
         break;
-        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_WRONG_VALUE:
+            emit worker->replaceLast(CHECK_UPDATE_TRIGGER_SET, UPDATE_STEP_WRONG);
             emit worker->showErrorMessage(worker->m_guiMsg);
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
             emit worker->replaceLast(CHECK_UPDATE_TRIGGER_SET, UPDATE_STEP_FAIL);
+            emit worker->showErrorMessage(worker->m_guiMsg);
+        break;
+        case UPDATE_STEP::INITIAL_CLONE_WITHOUT_ACTIVE_ISMAS_TRIGGER:
+        break;
+        case UPDATE_STEP::INITIAL_CLONE_WITH_ACTIVE_ISMAS_TRIGGER:
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH:
+            emit worker->appendText("\nPrepare customer environment ...");
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH_SUCCESS:
+            emit worker->replaceLast("Prepare customer environment ...", UPDATE_STEP_DONE);
+        break;
+        case UPDATE_STEP::CHECKOUT_BRANCH_FAILURE:
+            emit worker->replaceLast("Prepare customer environment ...", UPDATE_STEP_FAIL);
+            emit worker->showErrorMessage(worker->m_guiMsg);
         break;
         case UPDATE_STEP::UPDATE_REPOSITORY:
+            emit worker->appendText("\nUpdate repository...");
         break;
         case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
+            emit worker->replaceLast(QString("Update repository ..."), UPDATE_STEP_DONE);
         break;
         case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
+            emit worker->replaceLast(QString("Update repository ..."), UPDATE_STEP_FAIL);
         break;
         case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
         break;
@@ -747,8 +1088,59 @@ private:
         break;
         case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
         break;
+        case UPDATE_STEP::FILES_TO_UPDATE: {
+
+            qCritical() << "FILES_TO_UPDATE" << worker->m_filesToUpdate;
+
+            int const size = worker->m_filesToUpdate.size();
+            if (size > 1) {
+                emit worker->appendText(QString("Found %1 files to update :").arg(size), UPDATE_STEP_DONE);
+                for (int i = 0; i < size; ++i) {
+                    emit worker->appendText(QString("\n ") + worker->m_filesToUpdate.at(i));
+                }
+            } else {
+                emit worker->appendText("Found 1 file to update :", UPDATE_STEP_DONE);
+                emit worker->appendText(QString("\n ") + worker->m_filesToUpdate.at(0));
+            }
+        } break;
         case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
         break;
+        case UPDATE_STEP::FILES_TO_DOWNLOAD:
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMANDS:
+            emit worker->appendText("\n( ) Update opkg pakets ...");
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_1:
+            __attribute__((fallthrough));
+            // [[fallthrough]] -> c++17 -> unknown for clang
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_2:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_3:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_4:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_5:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_6:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_7:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_8:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_9:
+            __attribute__((fallthrough));
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_LAST:
+        break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_SUCCESS: {
+            QString prepend = QString("(") + QString("%1").arg(worker->m_displayIndex).rightJustified(3, ' ') + QString(")")
+                                + QString(" Update opkg pakets ... ");
+            worker->m_opkgCommands.prepend(prepend);
+            emit worker->replaceLast(worker->m_opkgCommands, UPDATE_STEP_DONE);
+        } break;
+        case UPDATE_STEP::EXEC_OPKG_COMMAND_FAILURE: {
+            emit worker->replaceLast(QString("(") + QString("%1").arg(worker->m_displayIndex).rightJustified(3, ' ') + QString(")")
+                          + QString(" Update opkg pakets ... "), UPDATE_STEP_FAIL);
+        } break;
         case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
         break;
         case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
@@ -766,10 +1158,13 @@ private:
         case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
         break;
         case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
+            emit worker->appendText("\nSync customer environment with filesystem ...");
         break;
         case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
+            emit worker->replaceLast(QString("Sync customer environment with filesystem ..."), UPDATE_STEP_DONE);
         break;
         case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
+            emit worker->replaceLast(QString("Sync customer environment with filesystem ..."), UPDATE_STEP_FAIL);
         break;
         case UPDATE_STEP::SAVE_LOGS:
         break;
@@ -778,10 +1173,15 @@ private:
         case UPDATE_STEP::SAVE_LOGS_FAILURE:
         break;
         case UPDATE_STEP::SEND_LAST_VERSION:
+            emit worker->appendText(QString("Send last version info "), UPDATE_STEP_DONE);
         break;
         case UPDATE_STEP::UPDATE_SUCCEEDED:
+            emit worker->appendText(QString("UPDATE "), UPDATE_STEP_SUCCESS);
+        break;
+        case UPDATE_STEP::UPDATE_ACTIVATED:
         break;
         case UPDATE_STEP::UPDATE_FAILED:
+            emit worker->appendText(QString("UPDATE "), UPDATE_STEP_FAIL);
         break;
         case UPDATE_STEP::FINISHED:
         break;
@@ -793,6 +1193,8 @@ private:
         break;
         }
 
+        worker->m_guiMsg.clear();
+
         return step;
     }
 };