Gerhard Hoffmann
c503750e90
onHandleChangedFiles(): split handling of opkg_commands-file and downloading of DC/JSON-Files. rsync to file-system only once these operations were successful.
428 lines
17 KiB
C++
428 lines
17 KiB
C++
#include "worker.h"
|
|
#include "update.h"
|
|
|
|
#include <QCoreApplication>
|
|
#include <QApplication>
|
|
#include <QDebug>
|
|
#include <QTimer>
|
|
#include <QFileInfo>
|
|
#include <QDir>
|
|
#include <QDirIterator>
|
|
#include <QThread>
|
|
#include <QRegularExpression>
|
|
#include <QDateTime>
|
|
#include <QString>
|
|
|
|
#include "message_handler.h"
|
|
#include "plugins/interfaces.h"
|
|
#include "ismas/ismas_client.h"
|
|
#include "apism/apism_client.h"
|
|
|
|
int Worker::read1stLineOfFile(QString fileName) {
|
|
QFile f(fileName);
|
|
if (f.exists()) {
|
|
if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
QTextStream in(&f);
|
|
in.setCodec("UTF-8");
|
|
while(!in.atEnd()) {
|
|
return in.readLine().toInt();
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
Worker::Worker(hwinf *hw,
|
|
int customerNr,
|
|
int machineNr,
|
|
int zoneNr,
|
|
QString branchName,
|
|
QString workingDirectory,
|
|
bool maintenanceMode,
|
|
bool dryRun,
|
|
QObject *parent,
|
|
char const *serialInterface,
|
|
char const *baudrate)
|
|
: m_workerThread("workerThread")
|
|
, m_apismClient(0, 0, 0, this) // TODO
|
|
, m_customerNr(customerNr)
|
|
, m_customerNrStr(QString("customer_") + QString::number(m_customerNr).rightJustified(3, '0'))
|
|
, m_machineNr(machineNr)
|
|
, m_zoneNr(zoneNr)
|
|
, m_workingDirectory(workingDirectory)
|
|
, m_branchName(branchName)
|
|
, m_customerRepository(QDir::cleanPath(m_workingDirectory + QDir::separator() + m_customerNrStr))
|
|
, m_gc(m_customerNrStr, m_customerRepository, m_workingDirectory, m_branchName, this)
|
|
, m_maintenanceMode(maintenanceMode)
|
|
, m_osVersion(getOsVersion())
|
|
, m_ismasUpdateRequests(ISMAS_UPDATE_REQUESTS)
|
|
, m_waitForNewUpdates(this) {
|
|
|
|
QDir::setCurrent(m_workingDirectory);
|
|
|
|
qInfo() << "CURRENT TIME ..............." << QDateTime::currentDateTime().toString(Qt::ISODate);
|
|
qInfo() << "OS VERSION ................." << m_osVersion;
|
|
qInfo() << "CUSTOMER_NR ................" << m_customerNr;
|
|
qInfo() << "CUSTOMER_NR_STR ............" << m_customerNrStr;
|
|
qInfo() << "CUSTOMER_REPOSITORY_PATH ..." << QString("https://git.mimbach49.de/GerhardHoffmann/%1.git").arg(m_customerNrStr);
|
|
qInfo() << "CUSTOMER_REPOSITORY ........" << m_customerRepository;
|
|
qInfo() << "MACHINE_NR ................." << m_machineNr;
|
|
qInfo() << "ZONE_NR ...................." << m_zoneNr;
|
|
qInfo() << "BRANCH_NAME ................" << m_branchName;
|
|
qInfo() << "WORKING_DIRECTORY .........." << m_workingDirectory;
|
|
|
|
QProcess p;
|
|
p.start("/bin/systemctl", {"restart", "apism"});
|
|
if (!p.waitForStarted(5000) || !p.waitForFinished(5000)) {
|
|
qCritical() << "APISM-RESTART-FAILURE";
|
|
return;
|
|
}
|
|
|
|
this->moveToThread(&m_workerThread);
|
|
m_workerThread.start();
|
|
|
|
int cnt = 0;
|
|
while (!m_workerThread.isRunning()) {
|
|
if (++cnt > 5) {
|
|
qCritical() << "starting worker thread FAILED";
|
|
return;
|
|
}
|
|
QThread::sleep(1);
|
|
}
|
|
|
|
connect(&m_apismClient, SIGNAL(ismasResponseAvailable(QJsonObject)), this,
|
|
SLOT(onIsmasResponseReceived(QJsonObject)));
|
|
connect(this, SIGNAL(summarizeRepositoryStatus()), this,
|
|
SLOT(onSummarizeRepositoryStatus()), Qt::QueuedConnection);
|
|
connect(this, SIGNAL(sendCmdSendVersionToIsmas()), this,
|
|
SLOT(onSendCmdSendVersionToIsmas()), Qt::QueuedConnection);
|
|
connect(this, SIGNAL(summarizeUpload(QStringList)), this,
|
|
SLOT(onSummarizeUpload(QStringList)), Qt::QueuedConnection);
|
|
connect(this, SIGNAL(handleChangedFiles(QStringList)), this,
|
|
SLOT(onHandleChangedFiles(QStringList)), Qt::QueuedConnection);
|
|
connect(this, SIGNAL(finishUpdateProcess(bool)), this,
|
|
SLOT(onFinishUpdateProcess(bool)), Qt::QueuedConnection);
|
|
connect(this, SIGNAL(terminateUpdateProcess()), this,
|
|
SLOT(onTerminateUpdateProcess()), Qt::QueuedConnection);
|
|
|
|
QDir customerRepository(m_customerRepository);
|
|
if (!customerRepository.exists()) {
|
|
if (m_gc.gitCloneAndCheckoutBranch()) {
|
|
// do nothing else, not even executing opkg-commands
|
|
onFinishUpdateProcess(false);
|
|
}
|
|
} else {
|
|
m_update = new Update(hw, m_customerRepository, m_customerNrStr,
|
|
m_branchName, m_workingDirectory,
|
|
dryRun, parent, serialInterface, baudrate);
|
|
|
|
connect(&m_startUpdateProcess, SIGNAL(timeout()), this, SLOT(askIsmasForNewData()), Qt::QueuedConnection);
|
|
m_startUpdateProcess.setSingleShot(true);
|
|
m_startUpdateProcess.start(1000);
|
|
|
|
connect(&m_waitForNewUpdates, SIGNAL(timeout()), this, SLOT(askIsmasForNewData()), Qt::QueuedConnection);
|
|
m_waitForNewUpdates.setSingleShot(false);
|
|
}
|
|
}
|
|
|
|
Worker::~Worker() {
|
|
int cnt = 0;
|
|
m_workerThread.quit();
|
|
while (!m_workerThread.isFinished()) {
|
|
if (!m_workerThread.wait(1000)) {
|
|
if (++cnt > 5) {
|
|
qCritical() << "stopping worker thread FAILED";
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (m_update) {
|
|
delete m_update;
|
|
}
|
|
}
|
|
|
|
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");
|
|
if (c.execute(m_workingDirectory, QStringList() << "-c" << cmd)) {
|
|
return c.getCommandResult();
|
|
}
|
|
return "N/A";
|
|
}
|
|
|
|
void Worker::onHandleChangedFiles(QStringList changedFiles) {
|
|
qCritical() << QDir::currentPath() << "ON HANDLE CHANGED FILES" << changedFiles;
|
|
|
|
QString opkg_commands;
|
|
static const QRegularExpression re("^.*opkg_commands\\s*$");
|
|
static const QRegularExpression comment("^\\s*#.*$");
|
|
int idx = changedFiles.indexOf(re);
|
|
if (idx != -1) {
|
|
m_updateStatus = UPDATE_STATUS::EXEC_OPKG_COMMANDS_REQUEST;
|
|
m_statusDescription = "EXECUTE OPKG COMMANDS";
|
|
|
|
opkg_commands = changedFiles.takeAt(idx);
|
|
|
|
QFile f(opkg_commands);
|
|
if (f.open(QIODevice::ReadOnly)) {
|
|
QTextStream in(&f);
|
|
while (!in.atEnd()) {
|
|
QString line = in.readLine();
|
|
if (line.indexOf(comment, 0) == -1) {
|
|
// found opkg command
|
|
QString opkgCommand = line.trimmed();
|
|
executeOpkgCommand(opkgCommand);
|
|
}
|
|
}
|
|
}
|
|
|
|
// m_updateStatus = UPDATE_STATUS::EXEC_OPKG_COMMANDS_SUCCESS;
|
|
// m_statusDescription = QString("EXECUTE OPKG COMMANDS %1 OK").arg(opkgCommands.join('\n'));
|
|
|
|
f.close();
|
|
}
|
|
|
|
if (m_update->doUpdate(changedFiles)) { // first update the hardware
|
|
// then sync the file-system
|
|
if (QDir(m_customerRepository).exists()) {
|
|
if (QDir::setCurrent(m_customerRepository)) {
|
|
QString const params("--recursive "
|
|
"--progress "
|
|
"--checksum "
|
|
"--exclude=.* "
|
|
"--include=*.bin "
|
|
"--include=*.json "
|
|
"--include=opkg_commands "
|
|
"--include=*.ini");
|
|
QStringList cmds;
|
|
cmds << QString("rsync ") + params.simplified() + " etc/ /etc";
|
|
cmds << QString("rsync ") + params.simplified() + " opt/ /opt";
|
|
|
|
QString cmd;
|
|
bool error = false;
|
|
foreach (cmd, cmds) {
|
|
if (!error) {
|
|
Command c("bash");
|
|
qInfo() << "EXCUTING CMD..." << cmd;
|
|
if (c.execute(m_customerRepository, QStringList() << "-c" << cmd)) {
|
|
qDebug() << c.getCommandResult();
|
|
} else {
|
|
qCritical() << "CMD" << cmd << "FAILED";
|
|
error = true;
|
|
}
|
|
}
|
|
}
|
|
if (!error) {
|
|
onFinishUpdateProcess(true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
onTerminateUpdateProcess();
|
|
}
|
|
|
|
void Worker::onSummarizeUpload(QStringList changedFiles) {
|
|
QDateTime const c = QDateTime::currentDateTime();
|
|
QDate const d = c.date();
|
|
QTime const t = c.time();
|
|
|
|
QString uploadHistoryFile = QString("upload_history_%1%2%3T%4%5%6.txt")
|
|
.arg(d.year()).arg(d.month()).arg(d.day())
|
|
.arg(t.hour()).arg(t.minute()).arg(t.second());
|
|
|
|
QFile f(uploadHistoryFile);
|
|
if (f.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
QTextStream out(&f);
|
|
QString fName;
|
|
foreach (fName, changedFiles) {
|
|
QString lastCommit = m_gc.gitLastCommit(fName);
|
|
out << fName << ":" << lastCommit << "\n";
|
|
}
|
|
} else {
|
|
// TODO: error an ISMAS
|
|
}
|
|
}
|
|
|
|
void Worker::onSummarizeRepositoryStatus() {
|
|
// TODO
|
|
QString dir("/opt/app/tools/atbupdate/customer_999");
|
|
QDirIterator it(dir, QStringList() << "*.jpg",
|
|
QDir::Files, QDirIterator::Subdirectories);
|
|
while (it.hasNext()) {
|
|
qDebug() << it.next();
|
|
if (m_gc.gitIsFileTracked(it.next())) {
|
|
QString lastCommit = m_gc.gitLastCommit(it.next());
|
|
}
|
|
}
|
|
|
|
/*
|
|
QString repoStatusHistoryFile = QString("repo_status_history_%1%2%3T%4%5%6.txt")
|
|
.arg(d.year()).arg(d.month()).arg(d.day())
|
|
.arg(t.hour()).arg(t.minute()).arg(t.second());
|
|
if (f.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
QTextStream out(&f);
|
|
QString fName;
|
|
foreach (fName, changedFiles) {
|
|
QString lastCommit = m_gc.gitLastCommit(fName);
|
|
out << fName << ":" << lastCommit << "\n";
|
|
}
|
|
} else {
|
|
// TODO: error an ISMAS
|
|
}
|
|
*/
|
|
}
|
|
|
|
void Worker::executeOpkgCommand(QString opkgCommand) {
|
|
Command c(opkgCommand);
|
|
if (c.execute(m_workingDirectory)) {
|
|
QString const r = c.getCommandResult();
|
|
m_updateStatus = UPDATE_STATUS::EXEC_OPKG_COMMAND_SUCCESS;
|
|
m_statusDescription = QString("EXECUTE OPKG COMMAND %1 OK").arg(opkgCommand);
|
|
} else {
|
|
m_updateStatus = UPDATE_STATUS::EXEC_OPKG_COMMAND_FAILURE;
|
|
m_statusDescription = QString("EXECUTE OPKG COMMAND %1 FAILED").arg(opkgCommand);
|
|
onTerminateUpdateProcess();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// sollte ParameterResponse heissen
|
|
void Worker::onIsmasResponseReceived(QJsonObject ismasResponse) {
|
|
if (!ismasResponse.isEmpty()) {
|
|
QStringList const keys = ismasResponse.keys();
|
|
static QRegularExpression re("^REQ_ISMASPARAMETER.*");
|
|
if(keys.indexOf(re) >= 0) {
|
|
m_waitForNewUpdates.stop(); // stop asking ISMAS for updates
|
|
|
|
// sanity check: cust_nr and machine_nr of PSA correct ?
|
|
if (keys.contains("Dev_ID", Qt::CaseInsensitive)) {
|
|
QJsonObject const devId = ismasResponse["Dev_ID"].toObject();
|
|
QStringList const keys = devId.keys();
|
|
if (keys.contains("Custom_ID") && keys.contains("Device_ID")) {
|
|
QJsonValue const c = devId.value("Custom_ID");
|
|
QJsonValue const m = devId.value("Device_ID");
|
|
int customerNr = c.toInt(-1);
|
|
int machineNr = m.toInt(-1);
|
|
if (customerNr != m_customerNr) {
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_FAILURE;
|
|
m_statusDescription
|
|
= QString("CUSTOMER-NR (%1) != LOCAL CUSTOMER-NR (%2)")
|
|
.arg(customerNr).arg(m_customerNr);
|
|
return;
|
|
}
|
|
if (machineNr != m_machineNr) {
|
|
m_statusDescription
|
|
= QString("MACHINE-NR (%1) != LOCAL MACHINE-NR (%2)")
|
|
.arg(machineNr).arg(m_machineNr);
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_FAILURE;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
// TODO: check if zone_nr is correct
|
|
|
|
if (keys.contains("Fileupload", Qt::CaseInsensitive)) {
|
|
QJsonObject fileUpload = ismasResponse["Fileupload"].toObject();
|
|
QJsonValue v = fileUpload.value("TRG");
|
|
if (!v.isNull() && !v.isUndefined()) {
|
|
QString const s = v.toString("");
|
|
if (s == "WAIT") {
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_SUCCESS;
|
|
m_ismasUpdateRequests = ISMAS_UPDATE_REQUESTS;
|
|
m_statusDescription = "ISMAS UPDATES AVAILABLE";
|
|
emit m_gc.ismasUpdatesAvailable();
|
|
}
|
|
}
|
|
} else {
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_FAILURE;
|
|
m_statusDescription = "NO FILEUPLOAD KEY AVAILABLE";
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_FAILURE;
|
|
m_statusDescription = "NO ISMAS RESPONSE AVAILABLE (EMPTY)";
|
|
}
|
|
}
|
|
|
|
void Worker::onFinishUpdateProcess(bool changes) {
|
|
qCritical() << "ON FINISH UPDATE PROCESS. CHANGES=" << changes;
|
|
m_workerThread.quit();
|
|
QApplication::quit();
|
|
}
|
|
|
|
|
|
void Worker::onTerminateUpdateProcess() {
|
|
qCritical() << "ON TERMINATE UPDATE PROCESS";
|
|
m_workerThread.quit();
|
|
QApplication::quit();
|
|
}
|
|
|
|
void Worker::onSendCmdSendVersionToIsmas() {
|
|
|
|
QString const tariffVersion = "0.0.1";
|
|
QString const tariffProject = "test_project";
|
|
int tariffZone = 1;
|
|
QString const tariffInfo = "test_tariff_info";
|
|
QString const tariffLoadTime = QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
|
|
// QString const linuxVersion = "test_linux_version";
|
|
QString const cpuSerial = "test_cpu_serial";
|
|
QString const deviceControllerVersion = "test_dc_version";
|
|
QString const deviceControllerGitBlob = "test_dc_blob_2a3b4f50";
|
|
QString const deviceControllerGitLastCommit = "test_dc_commit_12345abc";
|
|
QString const raucVersion = "test_rauc_version";
|
|
QString const opkgVersion = "test_opkg_version";
|
|
QString const atbQTVersion = "test_qtbqt_version";
|
|
QString const atbQTGitDescribe = "test_atbqt_git_describe";
|
|
QString const deviceControllerPluginVersion = "test_CAmaster_version";
|
|
QString const ingenicoISelfCCPluginVersion = "test_ingenico_plugin_version";
|
|
QString const mobilisisCalculatePricePluginVersion = "test_mobilisis_plugin_version";
|
|
QString const mobilisisCalculatePriceConfigUiVersion = "test_mobilisis_config_ui_plugin";
|
|
QString const prmCalculatePricePluginVersion = "test_prm_calculate_price_plugin";
|
|
QString const prmCalculatePriceConfigUiPluginVersion = "test_prm_calculate_price_config_ui_plugin";
|
|
QString const tcpZVTPluginVersion = "test_tcp_zvt_plugin";
|
|
|
|
QString data = m_ismasClient.updateOfPSASendVersion(tariffVersion,
|
|
tariffProject,
|
|
tariffZone,
|
|
tariffInfo,
|
|
tariffLoadTime,
|
|
m_osVersion,
|
|
cpuSerial,
|
|
deviceControllerVersion,
|
|
deviceControllerGitBlob,
|
|
deviceControllerGitLastCommit,
|
|
raucVersion,
|
|
opkgVersion,
|
|
atbQTVersion,
|
|
atbQTGitDescribe,
|
|
deviceControllerPluginVersion,
|
|
ingenicoISelfCCPluginVersion,
|
|
mobilisisCalculatePricePluginVersion,
|
|
mobilisisCalculatePriceConfigUiVersion,
|
|
prmCalculatePricePluginVersion,
|
|
prmCalculatePriceConfigUiPluginVersion,
|
|
tcpZVTPluginVersion);
|
|
m_apismClient.sendCmdSendVersionToIsmas(data);
|
|
}
|
|
|
|
void Worker::askIsmasForNewData() {
|
|
if (m_maintenanceMode) {
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_EMULATE_DATA_AVAILABLE;
|
|
QString data = m_ismasClient.setUpdatesAvailable();
|
|
m_apismClient.emulateUpdatesAvailable(data);
|
|
}
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_PENDING;
|
|
m_apismClient.requestAvailableIsmasUpdates();
|
|
|
|
if (--m_ismasUpdateRequests > 0) {
|
|
// if the timer is already running, it will be stopped and restarted.
|
|
m_waitForNewUpdates.start(10000);
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_PENDING;
|
|
} else {
|
|
m_updateStatus = UPDATE_STATUS::ISMAS_UPDATE_REQUEST_TIMEOUT;
|
|
onTerminateUpdateProcess();
|
|
}
|
|
}
|