824 lines
29 KiB
C++
824 lines
29 KiB
C++
#include "update.h"
|
|
|
|
#include <QCoreApplication>
|
|
#include <QApplication>
|
|
#include <QFile>
|
|
#include <QTemporaryFile>
|
|
#include <QDebug>
|
|
#include <QTextStream>
|
|
#include <QRegularExpression>
|
|
|
|
#include "plugins/interfaces.h"
|
|
|
|
#include <QSharedMemory>
|
|
#include <QScopedPointer>
|
|
#include <QDir>
|
|
#include <QThread>
|
|
#include <QDateTime>
|
|
#include <QPluginLoader>
|
|
#include <QMap>
|
|
|
|
#define COLUMN_REQUEST (0)
|
|
#define COLUMN_NAME (1)
|
|
#define COLUMN_DATE_TIME (2)
|
|
#define COLUMN_RESULT (3)
|
|
|
|
#define UPDATE_OPKG (1)
|
|
#define UPDATE_DC (0)
|
|
#define UPDATE_PRINTER_TEMPLATES (0)
|
|
#define UPDATE_CASH_TEMPLATE (0)
|
|
#define UPDATE_CONF_TEMPLATE (0)
|
|
#define UPDATE_DEVICE_TEMPLATE (0)
|
|
|
|
static const QMap<QString, int> baudrateMap = {
|
|
{"1200" , 0}, {"9600" , 1}, {"19200" , 2}, {"38400" , 3},
|
|
{"57600" , 4}, {"115200" , 5}
|
|
};
|
|
|
|
hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) {
|
|
hwinf *hw = nullptr;
|
|
if (plugInDir.exists()) {
|
|
QString pluginLibName(fname);
|
|
pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
|
|
QFileInfo info(pluginLibName);
|
|
if (info.exists()) {
|
|
pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
|
|
static QPluginLoader pluginLoader(pluginLibName);
|
|
if (!pluginLoader.load()) {
|
|
qCritical() << "in directory" << plugInDir.absolutePath();
|
|
qCritical() << "cannot load plugin" << pluginLoader.fileName();
|
|
qCritical() << pluginLoader.errorString();
|
|
exit(-1);
|
|
}
|
|
if (!pluginLoader.isLoaded()) {
|
|
qCritical() << pluginLoader.errorString();
|
|
exit(-2);
|
|
}
|
|
QObject *plugin = pluginLoader.instance();
|
|
if (!plugin) {
|
|
qCritical() << "cannot start instance";
|
|
exit(-3);
|
|
}
|
|
if (! (hw = qobject_cast<hwinf *>(plugin))) {
|
|
qCritical() << "cannot cast plugin" << plugin << "to hwinf";
|
|
exit(-4);
|
|
}
|
|
} else {
|
|
qCritical() << pluginLibName << "does not exist";
|
|
exit(-5);
|
|
}
|
|
} else {
|
|
qCritical() << "plugins directory" << plugInDir.absolutePath()
|
|
<< "does not exist";
|
|
exit(-6);
|
|
}
|
|
return hw;
|
|
}
|
|
|
|
Update::Update(hwinf *hw,
|
|
QString update_ctrl_file,
|
|
QString workingDir,
|
|
bool maintenanceMode,
|
|
QObject *parent,
|
|
char const *serialInterface,
|
|
char const *baudrate)
|
|
: QObject(parent)
|
|
, m_hw(hw)
|
|
, m_serialInterface(serialInterface)
|
|
, m_baudrate(baudrate)
|
|
, m_update_ctrl_file(update_ctrl_file)
|
|
, m_update_ctrl_file_copy(update_ctrl_file + ".copy")
|
|
, m_workingDir(workingDir)
|
|
, m_maintenanceMode(maintenanceMode)
|
|
, m_init(true) {
|
|
|
|
// make sure the files are empty
|
|
if (m_update_ctrl_file.exists()) {
|
|
if (m_update_ctrl_file.open(QIODevice::ReadWrite |
|
|
QIODevice::Truncate |
|
|
QIODevice::Text)) {
|
|
m_update_ctrl_file.close();
|
|
}
|
|
} else {
|
|
qCritical() << "Update-file" << m_update_ctrl_file.fileName()
|
|
<< "does not exist";
|
|
m_init = false;
|
|
}
|
|
if (m_update_ctrl_file_copy.exists()) {
|
|
if (m_update_ctrl_file_copy.open(QIODevice::ReadWrite |
|
|
QIODevice::Truncate |
|
|
QIODevice::Text)) {
|
|
m_update_ctrl_file_copy.close();
|
|
}
|
|
} else {
|
|
qCritical() << "Update-file-copy" << m_update_ctrl_file_copy.fileName()
|
|
<< "does not exist";
|
|
m_init = false;
|
|
}
|
|
|
|
// execute update_psa-script
|
|
if (m_init) {
|
|
if ((m_init = execUpdateScript()) == false) {
|
|
qCritical() << "UPDATE_SCRIPT FAILED";
|
|
} else {
|
|
if (!m_update_ctrl_file.open(QIODevice::ReadWrite | QIODevice::Text)) {
|
|
qCritical() << "CAN NOT OPEN" << m_update_ctrl_file.fileName();
|
|
m_init = false;
|
|
} else {
|
|
qDebug() << "OPENED" << m_update_ctrl_file.fileName();
|
|
}
|
|
if (!m_update_ctrl_file_copy.open(QIODevice::ReadWrite | QIODevice::Text)) {
|
|
qCritical() << "CAN NOT OPEN" << m_update_ctrl_file_copy.fileName();
|
|
m_init = false;
|
|
} else {
|
|
qDebug() << "OPENED" << m_update_ctrl_file_copy.fileName();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Update::~Update() {
|
|
// make sure the files are closed
|
|
m_update_ctrl_file.close();
|
|
m_update_ctrl_file_copy.close();
|
|
}
|
|
|
|
bool Update::execUpdateScript() {
|
|
// path of update-script 'update_psa'
|
|
QString update_psa("/opt/app/tools/atbupdate/update_psa ");
|
|
if (m_maintenanceMode) {
|
|
update_psa += " -m ";
|
|
}
|
|
update_psa += " --wdir ";
|
|
update_psa += m_workingDir;
|
|
|
|
qCritical() << "update_psa: " << update_psa;
|
|
|
|
QScopedPointer<QProcess> p(new QProcess(this));
|
|
p->setProcessChannelMode(QProcess::MergedChannels);
|
|
|
|
connect(&(*p), SIGNAL(readyReadStandardOutput()), this, SLOT(readyReadStandardOutput()));
|
|
connect(&(*p), SIGNAL(readyReadStandardError()), this, SLOT(readyReadStandardError()));
|
|
|
|
p->start(update_psa);
|
|
|
|
if (p->waitForStarted(1000)) {
|
|
if (p->state() == QProcess::ProcessState::Running) {
|
|
// maintenance_mode: update_psa script enters an infinite loop
|
|
int const timeout = (m_maintenanceMode ? 200000: -1);
|
|
if (p->waitForFinished(timeout)) {
|
|
QString output = p->readAllStandardOutput().toStdString().c_str();
|
|
QStringList lst = output.split('\n');
|
|
for (int i = 0; i < lst.size(); ++i) {
|
|
qDebug() << lst[i];
|
|
}
|
|
if (p->exitStatus() == QProcess::NormalExit) {
|
|
qInfo() << "EXECUTED" << update_psa
|
|
<< "with code" << p->exitCode();
|
|
return (p->exitCode() == 0);
|
|
}
|
|
} else {
|
|
qCritical() << "update-script TIMEDOUT after"
|
|
<< timeout/1000 << "seconds";
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Update::DownloadResult Update::sendStatus(int ret) const {
|
|
switch (ret) { // return values of dc are:
|
|
case 0: // 0: no answer by now
|
|
return DownloadResult::NOP; // 1: error
|
|
case 10: // 10: success
|
|
return DownloadResult::OK;
|
|
default:;
|
|
}
|
|
return DownloadResult::ERROR;
|
|
}
|
|
|
|
Update::DownloadResult Update::sendNextAddress(int bNum) const {
|
|
// sends address only if blockNumber is one of 0, 1024, 2048, 3072, 4096
|
|
int noAnswerCount = 0;
|
|
int errorCount = 0;
|
|
if ( bNum==0 || bNum==1024 || bNum==2048 || bNum==3072 || bNum==4096 ) {
|
|
qDebug() << "addr-block" << bNum << "...";
|
|
while (noAnswerCount <= 250) {
|
|
m_hw->bl_sendAddress(bNum);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
DownloadResult const res = sendStatus(m_hw->bl_wasSendingAddOK());
|
|
if (res != DownloadResult::NOP) {
|
|
if (res == DownloadResult::ERROR) {
|
|
if (++errorCount >= 10) {
|
|
qCritical() << "addr-block" << bNum << "...FAILED";
|
|
return res;
|
|
}
|
|
} else { // res == DownloadResult::OK
|
|
qInfo() << "addr-block" << bNum << "...OK";
|
|
return res;
|
|
}
|
|
} else {
|
|
noAnswerCount += 1; // no answer by now
|
|
}
|
|
}
|
|
// wait max. about 3 seconds
|
|
return DownloadResult::TIMEOUT;
|
|
}
|
|
// blockNumber is not one of 0, 1024, 2048, 3072, 4096 -> do nothing
|
|
return DownloadResult::NOP;
|
|
}
|
|
|
|
Update::DownloadResult Update::sendNextDataBlock(QByteArray const &binary,
|
|
int bNum) const {
|
|
uint8_t local[66];
|
|
int const bAddr = bNum * 64;
|
|
int noAnswerCount = 0;
|
|
int errorCount = 0;
|
|
|
|
memcpy(local, binary.constData() + bAddr, 64);
|
|
local[64] = local[65] = 0x00;
|
|
|
|
//for (int i=0; i<4; ++i) {
|
|
// printf("%04d ", bNum);
|
|
// for (int j=0; j < 16; ++j) {
|
|
// printf("%02x ", local[i*16 + j]);
|
|
// } printf("\n");
|
|
//}
|
|
|
|
while (noAnswerCount <= 250) {
|
|
m_hw->bl_sendDataBlock(64, local);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
DownloadResult const res = sendStatus(m_hw->bl_wasSendingDataOK());
|
|
if (res != DownloadResult::NOP) {
|
|
if (res == DownloadResult::ERROR) {
|
|
if (++errorCount >= 10) {
|
|
qCritical() << "data for block" << bNum << "...FAILED";
|
|
return res;
|
|
}
|
|
} else {
|
|
qInfo() << "data for block" << bNum << "OK";
|
|
return res;
|
|
}
|
|
} else {
|
|
noAnswerCount += 1; // no answer by now
|
|
}
|
|
}
|
|
// wait max. about 3 seconds
|
|
return DownloadResult::TIMEOUT;
|
|
}
|
|
|
|
Update::DownloadResult Update::dc_downloadBinary(QByteArray const &b) const {
|
|
int const nBlocks = (((b.size())%64)==0) ? (b.size()/64) : (b.size()/64)+1;
|
|
|
|
qInfo() << "total number of bytes to send to dc" << b.size();
|
|
qInfo() << "total number of blocks to send to dc" << nBlocks;
|
|
|
|
int bNum = 0;
|
|
DownloadResult res = DownloadResult::OK;
|
|
while (res != DownloadResult::ERROR && bNum < nBlocks) {
|
|
if ((res = sendNextAddress(bNum)) != DownloadResult::ERROR) {
|
|
if ((res = sendNextDataBlock(b, bNum)) != DownloadResult::ERROR) {
|
|
bNum += 1;
|
|
}
|
|
}
|
|
}
|
|
qInfo() << "nBlocks" << nBlocks;
|
|
//if (res != DownloadResult::ERROR) {
|
|
// always send last block, even when there are no data !!!
|
|
int const rest = b.size() % 64;
|
|
int const offset = b.size() - rest;
|
|
char const *startAddress = b.constData() + offset;
|
|
|
|
uint8_t local[66];
|
|
memset(local, 0x00, sizeof(local));
|
|
if (rest > 0) {
|
|
memcpy(local, startAddress, rest);
|
|
}
|
|
|
|
//for (int i=0; i<4; ++i) {
|
|
// printf("*** %04d ", bNum);
|
|
// for (int j=0; j < 16; ++j) {
|
|
// printf("%02x ", local[i*16 + j]);
|
|
// } printf("\n");
|
|
//}
|
|
|
|
// bl_sendLastBlock(local);
|
|
m_hw->bl_sendLastBlock();
|
|
qInfo() << "last result" << (int)sendStatus(m_hw->bl_wasSendingDataOK());
|
|
return res;
|
|
}
|
|
|
|
bool Update::startBootloader() const {
|
|
qDebug() << "starting bootloader...";
|
|
int nTry = 5;
|
|
while (--nTry >= 0) {
|
|
m_hw->bl_startBL();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
m_hw->bl_checkBL();
|
|
if (m_hw->bl_isUp()) {
|
|
qInfo() << "starting bootloader...OK";
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
return true;
|
|
} else {
|
|
qCritical() << "bootloader not up (" << nTry << ")";
|
|
}
|
|
}
|
|
qCritical() << "starting bootloader...FAILED";
|
|
return false;
|
|
}
|
|
|
|
bool Update::stopBootloader() const {
|
|
qDebug() << "stopping bootloader...";
|
|
int nTry = 5;
|
|
while (--nTry >= 0) {
|
|
m_hw->bl_stopBL();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
if (!m_hw->bl_isUp()) {
|
|
qInfo() << "stopping bootloader...OK";
|
|
return true;
|
|
}
|
|
}
|
|
qCritical() << "stopping bootloader...FAILED";
|
|
return false;
|
|
}
|
|
|
|
// br is a index into a table, used for historical reasons.
|
|
bool Update::openSerial(int br, QString baudrate, QString comPort) const {
|
|
qDebug() << "opening serial" << br << baudrate << comPort << "...";
|
|
if (m_hw->dc_openSerial(br, baudrate, comPort, 1)) { // 1 for connect
|
|
qInfo() << "opening serial" << br << baudrate << comPort << "...OK";
|
|
return true;
|
|
}
|
|
qCritical() << "opening serial" << br << baudrate << comPort << "...FAILED";
|
|
return false;
|
|
}
|
|
|
|
void Update::closeSerial() const {
|
|
m_hw->dc_closeSerial();
|
|
}
|
|
|
|
bool Update::resetDeviceController() const {
|
|
qDebug() << "resetting device controller...";
|
|
m_hw->bl_rebootDC();
|
|
// wait maximally 3 seconds, before starting bootloader
|
|
QThread::msleep(1500);
|
|
qInfo() << "resetting device controller...OK";
|
|
return true;
|
|
}
|
|
|
|
QByteArray Update::loadBinaryDCFile(QString filename) const {
|
|
qDebug() << "loading dc binary" << filename << "...";
|
|
|
|
QFile file(filename); // closed in destructor call
|
|
if (!file.exists()) {
|
|
qCritical() << file.fileName() << "does not exist";
|
|
return QByteArray();
|
|
}
|
|
if (!file.open(QIODevice::ReadOnly)) {
|
|
qCritical() << "cannot open file" << file.fileName();
|
|
return QByteArray();
|
|
}
|
|
qInfo() << "loading dc binary" << filename << "...OK";
|
|
return file.readAll();
|
|
}
|
|
|
|
bool Update::downloadBinaryToDC(QString const &bFile) const {
|
|
qDebug() << "sending" << bFile << "to dc...";
|
|
QByteArray const dcBinary = loadBinaryDCFile(bFile);
|
|
if (dcBinary.size() > 0) {
|
|
if (dc_downloadBinary(dcBinary) != DownloadResult::OK) {
|
|
qCritical() << "sending" << bFile << "to dc...FAILED";
|
|
return false;
|
|
} else {
|
|
qInfo() << "sending" << bFile << "to dc...OK";
|
|
}
|
|
} else {
|
|
qCritical() << "sending" << bFile << "to dc...FAILED";
|
|
qCritical() << "loading binary" << bFile << "FAILED";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Using the DC bootloader:
|
|
1 : bl_reboot() // send to application, want DC2 to reset (in order to start
|
|
// the bootloader)
|
|
2 : bl_startBL(): // send within 4s after DC poewer-on, otherwise bl is left
|
|
3 : bl_check(): // send command to verify if bl is up
|
|
4 : bl_isUp(): // returns true if bl is up and running
|
|
|
|
5 : bl_sendAddress(blockNumber)
|
|
// send start address, nr of 64-byte block, start with 0
|
|
// will be sent only for following block-numbers:
|
|
// 0, 1024, 2048, 3072 and 4096, so basically every 64kByte
|
|
// for other addresses nothing happens
|
|
|
|
6 : bl_wasSendingAddOK()
|
|
// return val: 0: no response by now
|
|
// 1: error
|
|
// 10: OK
|
|
|
|
7 : bl_sendDataBlock()
|
|
// send 64 byte from bin file
|
|
|
|
8 : bl_sendLastBlock()
|
|
// send this command after all data are transferred
|
|
|
|
9 : bl_wasSendingDataOK()
|
|
// return val: 0: no response by now
|
|
// 1: error
|
|
// 10: OK
|
|
|
|
10 : bl_stopBL() // leave bl and start (the new) application
|
|
*/
|
|
bool Update::updateBinary(char const *fileToSendToDC) {
|
|
qInfo() << "updating device controller binary" << fileToSendToDC;
|
|
QFile fn(fileToSendToDC);
|
|
bool r;
|
|
if ((r = fn.exists()) == true) {
|
|
QString const linkTarget = fn.symLinkTarget();
|
|
QFileInfo fi(linkTarget);
|
|
qInfo() << " updating binary (size=" << linkTarget << fi.size() << ")";
|
|
if ((r = updateDC(linkTarget)) == true) {
|
|
qInfo() << " updating binary (size=" << linkTarget << fi.size() << ") done";
|
|
} else {
|
|
qCritical() << "updating binary (size=" << linkTarget << fi.size() << ")... FAILED";
|
|
}
|
|
} else {
|
|
qCritical() << "symlink" << fileToSendToDC
|
|
<< "does not exist -> NO UPDATE OF DC FIRMWARE";
|
|
}
|
|
return r;
|
|
}
|
|
|
|
bool Update::updateDC(QString bFile) const {
|
|
qDebug() << "updating dc...";
|
|
qDebug() << "updating dc: file to send" << bFile;
|
|
if (!resetDeviceController()) {
|
|
return false;
|
|
}
|
|
if (!startBootloader()) {
|
|
return false;
|
|
}
|
|
if (!downloadBinaryToDC(bFile)) {
|
|
stopBootloader();
|
|
qCritical() << "updating dc: " << bFile << "...FAILED";
|
|
return false;
|
|
}
|
|
qInfo() << "updating dc: " << bFile << "...OK";
|
|
stopBootloader();
|
|
QThread::sleep(3);
|
|
return true;
|
|
}
|
|
|
|
QString Update::jsonType(enum FileTypeJson type) {
|
|
switch (type) {
|
|
case FileTypeJson::CASH: return "CASH";
|
|
case FileTypeJson::CONFIG: return "CONFIG";
|
|
case FileTypeJson::PRINTER: return "PRINTER";
|
|
case FileTypeJson::SERIAL: return "SERIAL";
|
|
case FileTypeJson::DEVICE: return "DEVICE";
|
|
case FileTypeJson::TIME: return "TIME";
|
|
}
|
|
return "N/A";
|
|
}
|
|
|
|
bool Update::downloadJson(enum FileTypeJson type,
|
|
int templateIdx,
|
|
QString jsFileToSendToDC) const {
|
|
|
|
qDebug() << "updating json-file:" << jsFileToSendToDC << "...";
|
|
qDebug() << " template-index:" << templateIdx;
|
|
qDebug() << " json-type:" << jsonType(type);
|
|
|
|
m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag
|
|
qDebug() << "SET AUTO-REQUEST=TRUE";
|
|
QThread::sleep(1); // make sure the auto-request flag is acknowledged
|
|
|
|
bool ready = false;
|
|
int nTry = 25;
|
|
while ((ready = m_hw->sys_ready4sending()) == false) {
|
|
QThread::msleep(200);
|
|
if (--nTry <= 0) {
|
|
qCritical() << "SYS NOT READY FOR SENDING AFTER 5 SECONDS";
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool ret = false;
|
|
if (ready) {
|
|
QFile file(jsFileToSendToDC);
|
|
QFileInfo fi(jsFileToSendToDC); // max. size of template file is 800 bytes
|
|
if (file.exists()) {
|
|
if (file.open(QIODevice::ReadOnly)) {
|
|
if (fi.size() <= 800) {
|
|
QByteArray ba = file.readAll();
|
|
if (m_hw->sys_sendJsonFileToDc((uint8_t)(type),
|
|
templateIdx,
|
|
(uint8_t *)ba.data())) {
|
|
QThread::sleep(1);
|
|
qDebug() << "SENT" << jsFileToSendToDC;
|
|
ret = true;
|
|
}
|
|
} else {
|
|
qCritical() << "SIZE OF" << jsFileToSendToDC
|
|
<< "TOO BIG (" << fi.size() << "BYTES)";
|
|
}
|
|
} else {
|
|
qCritical() << "CANNOT OPEN" << jsFileToSendToDC << "FOR READING";
|
|
}
|
|
} else {
|
|
qCritical() << jsFileToSendToDC << "DOES NOT EXIST";
|
|
}
|
|
}
|
|
|
|
m_hw->dc_autoRequest(false);
|
|
qDebug() << "SET AUTO-REQUEST=FALSE";
|
|
QThread::sleep(1); // make sure the auto-request flag is acknowledged
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool Update::updatePrinterTemplate(int templateIdx, QString jsFile) const {
|
|
return downloadJson(FileTypeJson::PRINTER, templateIdx, jsFile);
|
|
}
|
|
|
|
bool Update::updateConfig(QString jsFile) {
|
|
return downloadJson(FileTypeJson::CONFIG, 0, jsFile);
|
|
}
|
|
|
|
bool Update::updateCashConf(QString jsFile) {
|
|
return downloadJson(FileTypeJson::CASH, 0, jsFile);
|
|
}
|
|
|
|
bool Update::updateDeviceConf(QString jsFile) {
|
|
return downloadJson(FileTypeJson::DEVICE, 0, jsFile);
|
|
}
|
|
|
|
QStringList Update::getLinesToWorkOn() {
|
|
QStringList linesToWorkOn;
|
|
|
|
QTextStream in(&m_update_ctrl_file);
|
|
while (!in.atEnd()) {
|
|
QString line = in.readLine().trimmed();
|
|
if (line.startsWith("DONE")) {
|
|
m_update_ctrl_file_copy.write(line.toUtf8().constData());
|
|
m_update_ctrl_file_copy.write("\n");
|
|
} else {
|
|
linesToWorkOn << line;
|
|
}
|
|
}
|
|
return linesToWorkOn;
|
|
}
|
|
|
|
QStringList Update::split(QString line, QChar sep) {
|
|
QStringList lst;
|
|
QString next;
|
|
int start = 0, end;
|
|
|
|
while ((end = line.indexOf(sep, start)) != -1) {
|
|
next = line.mid(start, end - start).trimmed();
|
|
lst << next;
|
|
start = end + 1;
|
|
}
|
|
next = line.mid(start, end - start).trimmed();
|
|
lst << next;
|
|
|
|
return lst;
|
|
}
|
|
|
|
void Update::readyReadStandardOutput() {
|
|
QProcess *p = (QProcess *)sender();
|
|
QByteArray buf = p->readAllStandardOutput();
|
|
qCritical() << buf;
|
|
}
|
|
|
|
void Update::readyReadStandardError() {
|
|
QProcess *p = (QProcess *)sender();
|
|
QByteArray buf = p->readAllStandardError();
|
|
qCritical() << buf;
|
|
}
|
|
|
|
void Update::finished(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/) {
|
|
QProcess *p = (QProcess *)sender();
|
|
disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardOutput()));
|
|
disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardError()));
|
|
}
|
|
|
|
bool Update::doUpdate() {
|
|
|
|
/*
|
|
The file referred to by 'update_data' has the following structure for
|
|
each line:
|
|
|
|
# ======================================================================
|
|
# REQUEST | NAME | DATE | RESULT
|
|
# ======================================================================
|
|
# where
|
|
#
|
|
# STATUS: DOWNLOAD, EXECUTE or DONE
|
|
# NAME : If starting with 'opkg' it is an opkg-command to be executed.
|
|
# Otherwise its the name of a file which has to be updated.
|
|
# DATE : 0000-00-00T00:00:00
|
|
# RESULT: SUCCESS or ERROR (possibly with description)
|
|
#
|
|
*/
|
|
|
|
if (!m_init) {
|
|
qCritical() << "DO UPDATE: INITIALIZATION OR UPDATE-SCRIPT FAILED";
|
|
return false;
|
|
}
|
|
|
|
bool serialOpened = false;
|
|
|
|
QStringList linesToWorkOn = getLinesToWorkOn();
|
|
if (linesToWorkOn.size() == 0) {
|
|
qCritical() << "No lines to handle in" << m_update_ctrl_file.fileName();
|
|
return true;
|
|
}
|
|
|
|
qDebug() << "open lines...";
|
|
for (int i=0; i< linesToWorkOn.size(); ++i) {
|
|
qDebug() << "line" << i << ":" << linesToWorkOn.at(i).trimmed();
|
|
}
|
|
|
|
QList<QString>::const_iterator it;
|
|
for (it = linesToWorkOn.cbegin(); it != linesToWorkOn.cend(); ++it) {
|
|
bool res = false;
|
|
QString line = (*it).trimmed();
|
|
if (line.size() == 0 || line.startsWith(QChar('#'))) {
|
|
continue;
|
|
}
|
|
QStringList lst = split(line.trimmed());
|
|
if (lst.size() != 4) {
|
|
qCritical() << "PARSING ERROR FOR LINE"
|
|
<< line << "IN" << m_update_ctrl_file.fileName();
|
|
continue;
|
|
}
|
|
QString const &request = lst[COLUMN_REQUEST];
|
|
QString const &name = lst[COLUMN_NAME];
|
|
// QString const &datetime = lst[COLUMN_DATE_TIME];
|
|
// QString const &result = lst[COLUMN_RESULT];
|
|
qDebug() << "request=" << request << ", name=" << name;
|
|
if (request.trimmed() == "DOWNLOAD") {
|
|
if (!serialOpened) { // open serial code once
|
|
if (!openSerial(baudrateMap.value(m_baudrate), m_baudrate, m_serialInterface)) {
|
|
qCritical() << "CANNOT OPEN" << m_serialInterface << "(BAUDRATE="
|
|
<< m_baudrate << ")";
|
|
return false;
|
|
}
|
|
|
|
serialOpened = true;
|
|
|
|
QString fwVersion = m_hw->dc_getSWversion();
|
|
QString const hwVersion = m_hw->dc_getHWversion();
|
|
|
|
qInfo() << "current dc-hardware-version" << hwVersion;
|
|
qInfo() << "current dc-firmware-version" << fwVersion;
|
|
|
|
m_hw->dc_autoRequest(false);// default: turn auto-request setting off
|
|
QThread::sleep(3); // wait to be sure that there are no more
|
|
// commands sent to dc-hardware
|
|
qDebug() << "SET AUTO-REQUEST=FALSE";
|
|
}
|
|
if (name.contains("dc2c", Qt::CaseInsensitive) &&
|
|
name.endsWith(".bin", Qt::CaseInsensitive)) {
|
|
qInfo() << "downloading" << name.trimmed() << "to DC";
|
|
res = true;
|
|
#if UPDATE_DC == 1
|
|
if ((res = updateBinary(name.toStdString().c_str())) == true) {
|
|
qInfo() << "downloaded binary" << name;
|
|
}
|
|
#endif
|
|
} else if (name.contains("DC2C_print", Qt::CaseInsensitive)
|
|
&& name.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
#if UPDATE_PRINTER_TEMPLATES == 1
|
|
int i = name.indexOf("DC2C_print", Qt::CaseInsensitive);
|
|
int const templateIdx = name.mid(i).midRef(10, 2).toInt();
|
|
if ((templateIdx < 1) || (templateIdx > 32)) {
|
|
qCritical() << "WRONG TEMPLATE INDEX" << templateIdx;
|
|
res = false;
|
|
} else {
|
|
if ((res = updatePrinterTemplate(templateIdx, name))) {
|
|
qInfo() << "downloaded printer template"<< name;
|
|
}
|
|
}
|
|
#endif
|
|
} else if (name.contains("DC2C_cash", Qt::CaseInsensitive)
|
|
&& name.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
#if UPDATE_CASH_TEMPLATE == 1
|
|
if ((res = updateCashConf(name))) {
|
|
qInfo() << "downloaded cash template"<< name;
|
|
}
|
|
#endif
|
|
} else if (name.contains("DC2C_conf", Qt::CaseInsensitive)
|
|
&& name.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
#if UPDATE_CONF_TEMPLATE == 1
|
|
if ((res= updateConfig(name))) {
|
|
qInfo() << "downloaded config template"<< name;
|
|
}
|
|
#endif
|
|
} else if (name.contains("DC2C_device", Qt::CaseInsensitive)
|
|
&& name.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
#if UPDATE_DEVICE_TEMPLATE == 1
|
|
if ((res = updateDeviceConf(name))) {
|
|
qInfo() << "downloaded device template"<< name;
|
|
}
|
|
#endif
|
|
} else {
|
|
qCritical() << "UNKNOWN JSON FILE NAME" << name;
|
|
res = false;
|
|
}
|
|
} else if (request == "EXECUTE" && name.contains("opkg")) {
|
|
qInfo() << "starting" << name.trimmed();
|
|
res = true;
|
|
#if UPDATE_OPKG == 1
|
|
QScopedPointer<QProcess> p(new QProcess(this));
|
|
p->setProcessChannelMode(QProcess::MergedChannels);
|
|
|
|
connect(&(*p), SIGNAL(readyReadStandardOutput()), this, SLOT(readyReadStandardOutput()));
|
|
connect(&(*p), SIGNAL(readyReadStandardError()), this, SLOT(readyReadStandardError()));
|
|
|
|
p->start(name.trimmed());
|
|
|
|
if (p->waitForStarted(1000)) {
|
|
if (p->state() == QProcess::ProcessState::Running) {
|
|
if (p->waitForFinished(100000)) {
|
|
QString output = p->readAllStandardOutput();
|
|
QStringList outputLst = split(output, QChar('\n'));
|
|
for (int line=0; line < outputLst.size(); ++line) {
|
|
qDebug() << outputLst[line];
|
|
}
|
|
if (p->exitStatus() == QProcess::NormalExit) {
|
|
qInfo() << "EXECUTED" << name
|
|
<< "with code" << p->exitCode();
|
|
res = true;
|
|
} else {
|
|
qCritical() << "PROCESS" << name << "CRASHED";
|
|
}
|
|
} else {
|
|
qCritical() << "PROCESS" << name << "DID NOT FINISH";
|
|
}
|
|
} else {
|
|
qCritical() << "WRONG PROCESS STATE" << p->state();
|
|
}
|
|
} else {
|
|
qCritical() << "PROCESS" << name << "TIMEOUT AT START";
|
|
}
|
|
#endif
|
|
} else {
|
|
// TODO
|
|
}
|
|
char buf[128];
|
|
memset(buf, 0x00, sizeof(buf));
|
|
snprintf(buf, sizeof(buf)-1, "DONE, %*.*s, %*.*s, %*.*s\n",
|
|
35, 35, name.toStdString().c_str(),
|
|
20, 20, QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(),
|
|
10, 10, (res == true) ? "SUCCESS" : "ERROR");
|
|
m_update_ctrl_file_copy.write(buf);
|
|
|
|
qInfo() << "write" << buf << "into file" << m_update_ctrl_file_copy;
|
|
|
|
} // for (it = openLines.cbegin(); it != openLines.end(); ++it) {
|
|
|
|
if (serialOpened) {
|
|
m_hw->dc_autoRequest(true);
|
|
qDebug() << "SET AUTO-REQUEST=TRUE";
|
|
qInfo() << "current dc-hardware-version" << m_hw->dc_getHWversion();
|
|
qInfo() << "current dc-firmware-version" << m_hw->dc_getSWversion();
|
|
closeSerial();
|
|
serialOpened = false;
|
|
}
|
|
|
|
return finishUpdate(linesToWorkOn.size() > 0);
|
|
}
|
|
|
|
bool Update::finishUpdate(bool swapCtrlFiles) {
|
|
if (swapCtrlFiles) {
|
|
m_update_ctrl_file.close();
|
|
m_update_ctrl_file_copy.close();
|
|
|
|
QString const &fn = m_update_ctrl_file.fileName();
|
|
QString const &fn_tmp = m_update_ctrl_file.fileName() + ".tmp";
|
|
QString const &fn_copy = m_update_ctrl_file_copy.fileName();
|
|
QFile tmp(fn_tmp);
|
|
|
|
if (tmp.exists()) {
|
|
tmp.remove();
|
|
}
|
|
|
|
if (m_update_ctrl_file.rename(fn_tmp)) {
|
|
if (m_update_ctrl_file_copy.rename(fn)) {
|
|
return m_update_ctrl_file.rename(fn_copy);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|