GerhardHoffmann/UpdatePTUDevCtrl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9b0f741b9b
UpdatePTUDevCtrl/worker.h

718 lines
30 KiB
C++
Raw Blame History

#ifndef WORKER_H_INCLUDED
#define WORKER_H_INCLUDED
#include <QObject>
#include <QString>
#include <QStringList>
#include <QTimer>
#include <QFile>
#include <QJsonObject>
#include <QHash>
#include <QMap>
#include <QDebug>
#include <optional>
#include <initializer_list>
#include "worker_thread.h"
#include "update.h"
#include "git/git_client.h"
#include "ismas/ismas_client.h"
#include "utils.h"
#ifdef PTU5
#define SERIAL_PORT "ttymxc2"
#else
#define SERIAL_PORT "ttyUSB0"
#endif
#define _STARTED (1)
#define _CHECK_REPOSITORY (2)
#define _CHECK_SANITY (3)
#define _CHECK_SANITY_SUCCESS (4)
#define _CHECK_SANITY_FAILURE (5)
#define _CLONE_REPOSITORY (6)
#define _CLONE_REPOSITORY_SUCCESS (7)
#define _CLONE_REPOSITORY_FAILURE (8)
#define _SWITCH_BRANCH (12)
#define _SWITCH_BRANCH_SUCCESS (13)
#define _SWITCH_BRANCH_FAILURE (14)
#define _CHECK_ISMAS_TRIGGER (15)
#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_FOR_REPOSITORY_CHANGES (30)
#define _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS (38)
#define _CHECK_FOR_REPOSITORY_CHANGES_FAILURE (39)
#define _APPLY_REPOSITORY_CHANGES (40)
#define _DOWNLOAD_CONFIG_FILE (41)
#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 _SYNC_CUSTOMER_REPOSITORY (90)
#define _SYNC_CUSTOMER_REPOSITORY_SUCCESS (91)
#define _SYNC_CUSTOMER_REPOSITORY_FAILURE (92)
#define _SAVE_LOGS (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 _FINISHED (100)
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 ISMAS_UPDATE_REQUESTS (10)
class MainWindow;
class hwinf;
class Worker : public QObject {
Q_OBJECT
WorkerThread m_workerThread;
int const m_customerNr;
QString const m_customerNrStr;
int const m_machineNr;
int const m_zoneNr;
QString const m_pluginName;
QString const m_workingDirectory;
QString const m_branchName;
QString const m_customerRepositoryPath;
QString const m_customerRepository;
bool const m_dryRun;
QObject *m_parent;
QString const m_serialInterface;
QString const m_baudrate;
IsmasClient m_ismasClient;
GitClient m_gc;
QString const m_osVersion;
QString const m_atbqtVersion;
QString const m_atbUpdateToolVersion;
QString const m_cpuSerial;
QString const m_pluginVersionATBDeciceController;
QString const m_pluginVersionIngenicoISelf;
QString const m_pluginVersionMobilisisCalc;
QString const m_pluginVersionMobilisisCalcConfig;
QString const m_pluginVersionPrmCalc;
QString const m_pluginVersionPrmCalcConfig;
QString const m_pluginVersionTcpZvt;
int m_ismasUpdateRequests;
QTimer m_waitForNewUpdates;
UpdateStatus m_updateStatus;
QStringList m_filesToUpdate;
QStringList m_filesToDownload;
bool m_updateProcessRunning;
int m_displayIndex;
int m_returnCode;
MainWindow *m_mainWindow;
bool m_withoutIsmasDirectPort;
QString m_apismVersion;
bool executeOpkgCommand(QString opkgCommand);
QString getOsVersion() const;
QString getATBQTVersion() const;
QString getATBUpdateToolVersion() const;
QString getCPUSerial() const;
QString getRaucVersion() const;
QString getOpkgVersion() const;
QString getPluginVersion(QString const &pluginFileName) const;
QStringList getDCVersion() const;
qint64 getFileSize(QString const &fileName) const;
bool isRepositoryCorrupted();
bool repairCorruptedRepository();
int sendCloneAndCheckoutSuccess();
int sendCloneAndCheckoutFailure();
int sendIsmasTriggerFailure();
int sendPullFailure();
int sendFileUpdateFailure();
int sendRsyncFailure();
int sendLastVersionFailure();
int sendSaveLogFilesFailure();
int sendCustomerEnvironmentConfigurationFailed();
int sendFoundFilesToUpdateSuccess();
int sendUpdateSucceededAndActivated();
int sendFinalResult();
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;
enum class UPDATE_STEP {
STARTED = _STARTED,
CHECK_REPOSITORY = _CHECK_REPOSITORY,
CHECK_SANITY = _CHECK_SANITY,
CHECK_SANITY_SUCCESS = _CHECK_SANITY_SUCCESS,
CHECK_SANITY_FAILURE = _CHECK_SANITY_FAILURE,
CLONE_REPOSITORY = _CLONE_REPOSITORY,
CLONE_REPOSITORY_SUCCESS = _CLONE_REPOSITORY_SUCCESS,
CLONE_REPOSITORY_FAILURE = _CLONE_REPOSITORY_FAILURE,
SWITCH_BRANCH = _SWITCH_BRANCH,
SWITCH_BRANCH_SUCCESS = _SWITCH_BRANCH_SUCCESS,
SWITCH_BRANCH_FAILURE = _SWITCH_BRANCH_FAILURE,
CHECK_ISMAS_TRIGGER = _CHECK_ISMAS_TRIGGER,
CHECK_ISMAS_TRIGGER_SUCCESS = _CHECK_ISMAS_TRIGGER_SUCCESS,
CHECK_ISMAS_TRIGGER_FAILURE = _CHECK_ISMAS_TRIGGER_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,
APPLY_REPOSITORY_CHANGES = _APPLY_REPOSITORY_CHANGES,
DOWNLOAD_CONFIG_FILE = _DOWNLOAD_CONFIG_FILE,
DOWNLOAD_CONFIG_FILE_SUCCESS = _DOWNLOAD_CONFIG_FILE_SUCCESS,
DOWNLOAD_CONFIG_FILE_FAILURE = _DOWNLOAD_CONFIG_FILE_FAILURE,
DOWNLOAD_DEVICE_CONTROLLER = _DOWNLOAD_DEVICE_CONTROLLER,
DOWNLOAD_DEVICE_CONTROLLER_SUCCESS = _DOWNLOAD_DEVICE_CONTROLLER_SUCCESS,
DOWNLOAD_DEVICE_CONTROLLER_FAILURE = _DOWNLOAD_DEVICE_CONTROLLER_FAILURE,
APPLY_REPOSITORY_CHANGES_SUCCESS = _APPLY_REPOSITORY_CHANGES_SUCCESS,
APPLY_REPOSITORY_CHANGES_FAILURE = _APPLY_REPOSITORY_CHANGES_FAILURE,
SYNC_CUSTOMER_REPOSITORY = _SYNC_CUSTOMER_REPOSITORY,
SYNC_CUSTOMER_REPOSITORY_SUCCESS = _SYNC_CUSTOMER_REPOSITORY_SUCCESS,
SYNC_CUSTOMER_REPOSITORY_FAILURE = _SYNC_CUSTOMER_REPOSITORY_FAILURE,
SAVE_LOGS = _SAVE_LOGS,
SAVE_LOGS_SUCCESS = _SAVE_LOGS_SUCCESS,
SAVE_LOGS_FAILURE = _SAVE_LOGS_FAILURE,
SEND_LAST_VERSION = _SEND_LAST_VERSION,
UPDATE_SUCCEEDED = _UPDATE_SUCCEEDED,
UPDATE_FAILED = _UPDATE_FAILED,
FINISHED = _FINISHED
};
static Worker const *instance;
public:
static QString getATBUpdateToolYoctoVersion();
static QString getATBUpdateToolYoctoInstallationStatus();
static const QString UPDATE_STEP_OK;
static const QString UPDATE_STEP_DONE;
static const QString UPDATE_STEP_FAIL;
static const QString UPDATE_STEP_SUCCESS;
explicit Worker(int customerNr, // 281
int machineNr,
int zoneNr,
QString branchName,
QString pluginName,
QString workingDir = ".",
bool dryRun = false,
QObject *parent = nullptr,
char const *serialInterface = SERIAL_PORT,
char const *baudrate = "115200");
~Worker();
void setMainWindow(MainWindow *mainWindow) { m_mainWindow = mainWindow; }
hwinf *getPlugin();
hwinf const *getPlugin() const;
void setProgress(int progress);
void displayProgressInMainWindow(int progress);
void startProgressLoop();
void stopProgressLoop();
IsmasClient &getIsmasClient() { return m_ismasClient; }
IsmasClient const &getIsmasClient() const { return m_ismasClient; }
bool updateProcessRunning() const { return m_updateProcessRunning; }
int returnCode() const { return m_returnCode; }
int machineNr() const { return m_machineNr; }
int customerNr() const { return m_customerNr; }
int zoneNr() const { return m_zoneNr; }
QString apismVersion() const { return m_apismVersion; }
QString atbUpdateToolVersion() const { return m_atbUpdateToolVersion; }
MainWindow *mainWindow() { return m_mainWindow; }
MainWindow const *mainWindow() const { return m_mainWindow; }
signals:
void appendText(QString, QString suffix = "");
void replaceLast(QString, QString);
void replaceLast(QStringList, QString);
void showErrorMessage(QString title, QString description);
void showStatusMessage(QString title, QString description);
void stopStartTimer();
void restartExitTimer();
void enableExit();
void disableExit();
public slots:
void update();
private slots:
bool updateTriggerSet(int progress);
bool customerEnvironment(int progress);
bool filesToUpdate(int progress);
bool updateFiles(int percent);
bool syncCustomerRepositoryAndFS(int progress);
bool sendIsmasLastVersionNotification(int progress);
bool saveLogFile(int progress);
private:
PSAInstalled getPSAInstalled();
void privateUpdate();
std::optional<QString> getApismVersion();
void printProgress(UPDATE_STEP step);
static const QMap<UPDATE_STEP, const char*> smap;
friend UPDATE_STEP operator<<(QDebug debug, UPDATE_STEP step) {
if (!Worker::instance) {
return step;
}
static const QMap<UPDATE_STEP, const char*> smap (
std::initializer_list<std::pair<UPDATE_STEP, const char*>>{
#define INSERT_ELEMENT(p) std::pair(p, #p)
INSERT_ELEMENT(UPDATE_STEP::STARTED),
INSERT_ELEMENT(UPDATE_STEP::CHECK_REPOSITORY),
INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY),
INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY),
INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH),
INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER),
INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_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::APPLY_REPOSITORY_CHANGES),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY),
INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS),
INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SEND_LAST_VERSION),
INSERT_ELEMENT(UPDATE_STEP::UPDATE_SUCCEEDED),
INSERT_ELEMENT(UPDATE_STEP::UPDATE_FAILED),
INSERT_ELEMENT(UPDATE_STEP::FINISHED)
#undef INSERT_ELEMENT
});
switch (step) {
case UPDATE_STEP::STARTED: {
Utils::printUpdateStatusMsg(
debug,
QStringList(smap[step])
<< QString("CURRENT TIME ...............%1").arg(QDateTime::currentDateTime().toString(Qt::ISODate))
<< QString("OS VERSION .................%1").arg(instance->m_osVersion)
<< QString("ATBQT VERSION ..............%1").arg(instance->m_atbqtVersion)
<< QString("CPU SERIAL .................%1").arg(instance->m_cpuSerial)
<< QString("CUSTOMER_NR ................%1").arg(instance->m_customerNr)
<< QString("CUSTOMER_NR_STR ............%1").arg(instance->m_customerNrStr)
<< QString("CUSTOMER_REPOSITORY_PATH ...%1").arg(instance->m_customerRepositoryPath)
<< QString("CUSTOMER_REPOSITORY ........%1").arg(instance->m_customerRepository)
<< QString("MACHINE_NR .................%1").arg(instance->m_machineNr)
<< QString("ZONE_NR ....................%1").arg(instance->m_zoneNr)
<< QString("BRANCH_NAME ................%1").arg(instance->m_branchName)
<< QString("PLUGIN_NAME ................%1").arg(instance->m_pluginName)
<< QString("WORKING_DIRECTORY ..........%1").arg(instance->m_workingDirectory)
<< QString("APISM VERSION ..............%1").arg(instance->m_apismVersion)
<< QString("ATB UPDATE TOOL VERSION ....%1").arg(instance->m_atbUpdateToolVersion));
} break;
case UPDATE_STEP::CHECK_REPOSITORY:
break;
case UPDATE_STEP::CHECK_SANITY:
break;
case UPDATE_STEP::CHECK_SANITY_SUCCESS:
break;
case UPDATE_STEP::CHECK_SANITY_FAILURE:
break;
case UPDATE_STEP::CLONE_REPOSITORY:
break;
case UPDATE_STEP::CLONE_REPOSITORY_SUCCESS:
break;
case UPDATE_STEP::CLONE_REPOSITORY_FAILURE:
break;
case UPDATE_STEP::SWITCH_BRANCH:
break;
case UPDATE_STEP::SWITCH_BRANCH_SUCCESS:
break;
case UPDATE_STEP::SWITCH_BRANCH_FAILURE:
break;
case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
break;
case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
break;
case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
break;
case UPDATE_STEP::UPDATE_REPOSITORY:
break;
case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
break;
case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
break;
case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
break;
case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS:
break;
case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
break;
case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
break;
case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
break;
case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
break;
case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE:
break;
case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER:
break;
case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS:
break;
case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE:
break;
case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS:
break;
case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
break;
case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
break;
case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
break;
case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
break;
case UPDATE_STEP::SAVE_LOGS:
break;
case UPDATE_STEP::SAVE_LOGS_SUCCESS:
break;
case UPDATE_STEP::SAVE_LOGS_FAILURE:
break;
case UPDATE_STEP::SEND_LAST_VERSION:
break;
case UPDATE_STEP::UPDATE_SUCCEEDED:
break;
case UPDATE_STEP::UPDATE_FAILED:
break;
case UPDATE_STEP::FINISHED:
break;
}
return step;
}
friend UPDATE_STEP operator<<(IsmasClient &ismasClient, UPDATE_STEP step) {
if (!Worker::instance) {
return step;
}
static const QMap<UPDATE_STEP, const char*> smap (
std::initializer_list<std::pair<UPDATE_STEP, const char*>>{
#define INSERT_ELEMENT(p) std::pair(p, #p)
INSERT_ELEMENT(UPDATE_STEP::STARTED),
INSERT_ELEMENT(UPDATE_STEP::CHECK_REPOSITORY),
INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY),
INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::CHECK_SANITY_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY),
INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::CLONE_REPOSITORY_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH),
INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::SWITCH_BRANCH_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER),
INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::CHECK_ISMAS_TRIGGER_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::APPLY_REPOSITORY_CHANGES),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY),
INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS),
INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_SUCCESS),
INSERT_ELEMENT(UPDATE_STEP::SAVE_LOGS_FAILURE),
INSERT_ELEMENT(UPDATE_STEP::SEND_LAST_VERSION),
INSERT_ELEMENT(UPDATE_STEP::UPDATE_SUCCEEDED),
INSERT_ELEMENT(UPDATE_STEP::UPDATE_FAILED),
INSERT_ELEMENT(UPDATE_STEP::FINISHED)
#undef INSERT_ELEMENT
});
switch (step) {
case UPDATE_STEP::STARTED: {
ismasClient.setProgressInPercent(_STARTED);
} break;
case UPDATE_STEP::CHECK_REPOSITORY:
ismasClient.setProgressInPercent(_CHECK_REPOSITORY);
break;
case UPDATE_STEP::CHECK_SANITY:
ismasClient.setProgressInPercent(_CHECK_SANITY);
break;
case UPDATE_STEP::CHECK_SANITY_SUCCESS:
ismasClient.setProgressInPercent(_CHECK_SANITY_SUCCESS);
break;
case UPDATE_STEP::CHECK_SANITY_FAILURE:
ismasClient.setProgressInPercent(_CHECK_SANITY_FAILURE);
break;
case UPDATE_STEP::CLONE_REPOSITORY:
ismasClient.setProgressInPercent(_CLONE_REPOSITORY);
break;
case UPDATE_STEP::CLONE_REPOSITORY_SUCCESS:
ismasClient.setProgressInPercent(_CLONE_REPOSITORY_SUCCESS);
break;
case UPDATE_STEP::CLONE_REPOSITORY_FAILURE:
ismasClient.setProgressInPercent(_CLONE_REPOSITORY_FAILURE);
break;
case UPDATE_STEP::SWITCH_BRANCH:
ismasClient.setProgressInPercent(_SWITCH_BRANCH);
break;
case UPDATE_STEP::SWITCH_BRANCH_SUCCESS:
ismasClient.setProgressInPercent(_SWITCH_BRANCH_SUCCESS);
break;
case UPDATE_STEP::SWITCH_BRANCH_FAILURE:
ismasClient.setProgressInPercent(_SWITCH_BRANCH_FAILURE);
break;
case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER);
break;
case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_SUCCESS);
break;
case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_FAILURE);
break;
case UPDATE_STEP::UPDATE_REPOSITORY:
ismasClient.setProgressInPercent(_UPDATE_REPOSITORY);
break;
case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
ismasClient.setProgressInPercent(_UPDATE_REPOSITORY_SUCCESS);
break;
case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
ismasClient.setProgressInPercent(_UPDATE_REPOSITORY_FAILURE);
break;
case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES);
break;
case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS:
ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES_SUCCESS);
break;
case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES_FAILURE);
break;
case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES);
break;
case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE);
break;
case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE_SUCCESS);
break;
case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE:
ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE_FAILURE);
break;
case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER:
ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER);
break;
case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS:
ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER_SUCCESS);
break;
case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE:
ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER_FAILURE);
break;
case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS:
ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES_SUCCESS);
break;
case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES_FAILURE);
break;
case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY);
break;
case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY_SUCCESS);
break;
case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY_FAILURE);
break;
case UPDATE_STEP::SAVE_LOGS:
ismasClient.setProgressInPercent(_SAVE_LOGS);
break;
case UPDATE_STEP::SAVE_LOGS_SUCCESS:
ismasClient.setProgressInPercent(_SAVE_LOGS_SUCCESS);
break;
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:
ismasClient.setProgressInPercent(_UPDATE_FAILED);
break;
case UPDATE_STEP::FINISHED:
ismasClient.setProgressInPercent(_FINISHED);
break;
break;
}
return step;
}
#if 0
case UPDATE_STEP::CHECK_SANITY:
Utils::printUpdateStatusMsg(
QStringList()
<< QString("STEP 1: CHECKED SANITY OF CUSTOMER REPOSITORY %1 DONE")
.arg(instance->m_customerRepository)
<< QString("STEP 2: FETCH CUSTOMER REPOSITORY %1...")
.arg(instance->m_customerRepository));
break;
//case UPDATE_STEP::FETCH_REPOSITORY:
// Utils::printUpdateStatusMsg(
// QStringList()
// << QString("STEP 2: FETCHED CUSTOMER REPOSITORY %1 DONE")
// .arg(instance->m_customerRepository)
// << QString("STEP 3: CHECK ISMAS-UPDATE-TRIGGER FOR WAIT-STATUS..."));
// break;
case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
Utils::printUpdateStatusMsg(
QStringList()
<< QString("STEP 3: CHECKED ISMAS-UPDATE-TRIGGER FOR WAIT-STATUS. SUCCESS.")
<< QString("STEP 4: CHECK-OUT BRANCH %1...").arg(instance->m_gc.branchName()));
break;
case UPDATE_STEP::CHECKED_OUT_BRANCH:
Utils::printUpdateStatusMsg(
QStringList()
<< QString("STEP 4: CHECKED-OUT BRANCH %1 DONE")
.arg(instance->m_gc.branchName())
<< QString("STEP 5: COMPUTE FILES-TO-UPDATE..."));
break;
case UPDATE_STEP::COMPUTE_FILES_TO_UPDATE:
Utils::printUpdateStatusMsg(
QStringList()
<< QString("STEP 5: COMPUTE FILES-TO-UPDATE %1 DONE")
.arg(instance->m_filesToUpdate.join(','))
<< QString("STEP 6: DOWNLOAD FILES-TO-DOWNLOAD %1 AND EXECUTE OPKG_COMMANDS...")
.arg(instance->m_filesToDownload.join(',')));
break;
case UPDATE_STEP::DOWNLOAD_FILES_TO_UPDATE:
Utils::printUpdateStatusMsg(
QStringList()
<< QString("STEP 6: DOWNLOAD FILES-TO-DOWNLOAD %1 AND EXECUTE OPKG_COMMANDS DONE")
.arg(instance->m_filesToDownload.join(','))
<< QString("STEP 7: SYNC CUSTOMER REPOSITORY %1 WITH FILESYSTEM...")
.arg(instance->m_customerRepository));
break;
case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
Utils::printUpdateStatusMsg(
QStringList()
<< QString("STEP 7: SYNC CUSTOMER REPOSITORY %1 WITH FILESYSTEM DONE")
.arg(instance->m_customerRepository)
<< QString("STEP 8: SEND-LAST-VERSION TO ISMAS..."));
break;
case UPDATE_STEP::UPDATE_SUCCESS:
Utils::printUpdateStatusMsg(
QStringList()
<< QString("STEP 9: SAVE-LOG-FILES (FUTURE USE) DONE")
<< QString("STEP 10: MARK UPDATE AS SUCCESSFUL AND ACTIVE..."));
break;
}
#endif
friend UPDATE_STEP operator<<(MainWindow *mainWindow, UPDATE_STEP step) {
if (!Worker::instance) {
return step;
}
return step;
}
};
#endif // WORKER_H_INCLUDED
Reference in New Issue View Git Blame Copy Permalink