clients/EffectUI/sparentprocess.cpp

#include "sparentprocess.h"
#include "sutilfunction.h"
#include <QThread>
#include <QString>
#include <QDebug>

extern QString ERROR_MESSAGE[];

namespace
{
const int TIMEOUT = 180; // 3 minutes
const QString SPLIT_KEYWORD = "!@#";
}


SParentProcess::SParentProcess():m_pProcess(new QProcess(this)), m_bRunning(false), nTime(0),
    m_bUserAbort(false), m_eInnerMode(E_INNER_RUN_MODE::MODE_WAIT)
{
    QObject::connect(m_pProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
                     this, SLOT(finishedProcess(int, QProcess::ExitStatus)));
    QObject::connect(this, &SParentProcess::signalTerminateError,
                     this, &SParentProcess::slotTerminateError);
}

void SParentProcess::clear()
{
    m_vecError.clear();
    m_mapReportSummary.clear();
    m_erCurrentRow = SEffectRow();
    m_error = SError();
    m_bUserAbort = false;
    nTime = 0;
    m_bRunning = false;
}

void SParentProcess::setInnerMode(E_INNER_RUN_MODE _mode)
{
    m_eInnerMode = _mode;
}

QVector<SEffectRow> SParentProcess::getErrorList() const
{
    return m_vecError;
}

SReportSummary SParentProcess::getReportSummary(int _id) const
{
    return m_mapReportSummary.value(_id, SReportSummary());
}

QMap<int, SReportSummary> SParentProcess::getReportSummary() const
{
    return m_mapReportSummary;
}


SError SParentProcess::getError() const
{
    return m_error;
}

bool SParentProcess::isWaiting() const
{
    return m_eInnerMode == E_INNER_RUN_MODE::MODE_WAIT;
}

void SParentProcess::setModeWait()
{
    m_eInnerMode = E_INNER_RUN_MODE::MODE_WAIT;
}

QStringList SParentProcess::getProcessArguments(const SEffectRow& _row) const
{
    return QStringList();
}

QStringList SParentProcess::getProcessArguments(SEffectRow&& _row) const
{
    return QStringList();
}

void SParentProcess::runProcess(QStringList _arguments)
{
    if (_arguments.size() > 0)
    {
        QString arg = _arguments.at(0);
        _arguments.removeFirst();

        m_pProcess->start(arg, _arguments);
    }
    else
    {
        emit signalLog("x " + m_erCurrentRow.eventcode + " " + m_erCurrentRow.url + "\nERROR:NO_PROGRAM");
        emit signalTerminateEachEvent(m_erCurrentRow.company_num, E_CRAWL_STATE::FAIL);
        m_vecError.append(m_erCurrentRow);
        setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
    }
}

void SParentProcess::setError(const SError& _error)
{
    m_error = _error;
}

void SParentProcess::setError(SError&& _error)
{
    m_error = std::move(_error);
}

void SParentProcess::stop()
{
    m_bUserAbort = true;
}

void SParentProcess::update()
{
    switch(m_eInnerMode)
    {

    case E_INNER_RUN_MODE::MODE_WAIT:
    {
        setInnerMode(E_INNER_RUN_MODE::MODE_RUN_INIT);
        break;
    }

    case E_INNER_RUN_MODE::MODE_RUN_INIT:
    {
        runInit();
        break;
    }

    case E_INNER_RUN_MODE::MODE_RUN_EVENTCODE:
    {
        nTime = 0;
        runEventCode();
        break;
    }

    case E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE:
    {
        if (++nTime >= TIMEOUT)
        {
            setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_HANGING);
            m_pProcess->kill();
        }

        break;
    }

    case E_INNER_RUN_MODE::MODE_WAIT_INIT:
    {
        break;
    }

    case E_INNER_RUN_MODE::MODE_WAIT_TERMINATE:
    {
        break;
    }

    case E_INNER_RUN_MODE::MODE_WAIT_HANGING:
    {
        break;
    }

    }
}

void SParentProcess::finishedProcess(int exitCode, QProcess::ExitStatus exitStatus)
{
    if (m_bUserAbort)
    {
        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_HANGING);
        emit signalUserAbort();
        return;
    }
    QProcess *pPro = (QProcess*)sender();
    QThread::msleep(100);
    QString str = pPro->readAllStandardOutput();

    SError analyzedResult = analyzeStdOut(str);
    QString strLog = makeLog(analyzedResult);

    if (analyzedResult.state == E_CRAWL_STATE::OK)
    {
        if (!m_mapReportSummary.contains(analyzedResult.company_num))
            m_mapReportSummary.insert(analyzedResult.company_num, SReportSummary());
        m_mapReportSummary[analyzedResult.company_num].nOk++;
        //add emit signal Finished success?
    }
    else
    {
        if (!m_mapReportSummary.contains(analyzedResult.company_num))
            m_mapReportSummary.insert(analyzedResult.company_num, SReportSummary());
        m_mapReportSummary[analyzedResult.company_num].nError++;
        m_vecError.append(m_erCurrentRow);
    }

    emit signalLog(strLog);
    emit signalTerminateEachEvent(analyzedResult.company_num, analyzedResult.state);
    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);

    //This may be unnecessary :(
    //pPro->kill();
}


SError SParentProcess::analyzeStdOut(const QString& _str)
{
    SError errorResult;
    if (_str.trimmed().size() < 5) // may be timeout case
    {
        errorResult.state = E_CRAWL_STATE::FAIL;
        errorResult.company_num = m_erCurrentRow.company_num;
        errorResult.event_code = m_erCurrentRow.eventcode;
        errorResult.platformname_num = m_erCurrentRow.platformname_num;
        errorResult.error_code = E_ERROR_CODE::TIMEOUT;
        errorResult.url = m_erCurrentRow.url;
        errorResult.str_error = _str;

        return errorResult;
    }


    // unknown type log
    // This result is treated like unknown error.
    else if (_str.trimmed().at(0) != 'o' && _str.trimmed().at(0) != 'O' &&
             _str.trimmed().at(0) != 'x' && _str.trimmed().at(0) != 'X')
    {
        errorResult.state = E_CRAWL_STATE::FAIL;
        errorResult.company_num = m_erCurrentRow.company_num;
        errorResult.event_code = m_erCurrentRow.eventcode;
        errorResult.platformname_num = m_erCurrentRow.platformname_num;
        errorResult.error_code = E_ERROR_CODE::UNKNOWN_ERROR;
        errorResult.url = m_erCurrentRow.url;
        errorResult.str_error = _str.trimmed().left(200);

        return errorResult;
    }

    else
    {
        QStringList slLog = _str.split(SPLIT_KEYWORD);

        if (slLog.size() < 3)
        {
            errorResult.state = E_CRAWL_STATE::FAIL;
            errorResult.company_num = m_erCurrentRow.company_num;
            errorResult.event_code = m_erCurrentRow.eventcode;
            errorResult.platformname_num = m_erCurrentRow.platformname_num;
            errorResult.error_code = E_ERROR_CODE::UNKNOWN_ERROR;
            errorResult.url = m_erCurrentRow.url;
            errorResult.str_error = _str.trimmed().left(200);

            return errorResult;

        }
        else if ((slLog.at(0).trimmed() == "o" || slLog.at(0).trimmed() == "O"))
        {
            errorResult.state = E_CRAWL_STATE::OK;
            errorResult.company_num = m_erCurrentRow.company_num;
            errorResult.event_code = m_erCurrentRow.eventcode;
            errorResult.url = m_erCurrentRow.url;
            /*
            errorResult.event_code = slLog.at(static_cast<int>(E_LOG_COLUMN::EVENT_CODE));
            errorResult.url = slLog.at(static_cast<int>(E_LOG_COLUMN::URL));
            */
            return errorResult;
        }
        else if ((slLog.at(0).trimmed() == "x" || slLog.at(0).trimmed() == "X"))
        {
            errorResult.state = E_CRAWL_STATE::FAIL;
            errorResult.company_num = m_erCurrentRow.company_num;
            errorResult.platformname_num = m_erCurrentRow.platformname_num;

            /*
            errorResult.event_code = slLog.at(static_cast<int>(E_LOG_COLUMN::EVENT_CODE));
            errorResult.url = slLog.at(static_cast<int>(E_LOG_COLUMN::URL));
            */

            switch (slLog.size())
            {
            case static_cast<int>(E_LOG_COLUMN::ERROR_MSG) + 1:
            {
                errorResult.str_error = slLog.at(
                            static_cast<int>(E_LOG_COLUMN::ERROR_MSG)).trimmed();
            }
            case static_cast<int>(E_LOG_COLUMN::ERROR_CODE) + 1:
            {
                errorResult.error_code = strErrorCodeToEnumErrorCode(
                            slLog.at(static_cast<int>(E_LOG_COLUMN::ERROR_CODE)).trimmed());
            }
            case static_cast<int>(E_LOG_COLUMN::URL) + 1:
            {
                errorResult.event_code = slLog.at(
                            static_cast<int>(E_LOG_COLUMN::EVENT_CODE)).trimmed();
                errorResult.url = slLog.at(
                            static_cast<int>(E_LOG_COLUMN::URL)).trimmed();
            }
            }
            return errorResult;
        }
        else
        {
            errorResult.state = E_CRAWL_STATE::FAIL;
            errorResult.company_num = m_erCurrentRow.company_num;
            errorResult.event_code = m_erCurrentRow.eventcode;
            errorResult.platformname_num = m_erCurrentRow.platformname_num;
            errorResult.error_code = E_ERROR_CODE::UNKNOWN_ERROR;
            errorResult.url = m_erCurrentRow.url;
            errorResult.str_error = _str.trimmed().left(200);

            return errorResult;

        }
    }
}


QString SParentProcess::makeLog(const SError& _error)
{
    QString str;
    switch (_error.state)
    {
    case E_CRAWL_STATE::OK:
    {
        str += "o ";
        str += m_erCurrentRow.company_name + " ";
        str += _error.event_code + " ";
        str += _error.url + " ";
        break;
    }
    case E_CRAWL_STATE::FAIL:
    {
        str += "x ";
        str += m_erCurrentRow.company_name + " ";
        str += _error.event_code + " ";
        str += _error.url + "\n";
        str += "  ERROR:" + errorCodeToString(_error.error_code) + "\n";
        str += "  ERRORMSG:" + _error.str_error;
        break;
    }
    }
    return str;
}

void SParentProcess::slotTerminateError(const SError &_error)
{
    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
    emit signalLog(makeLog(_error));
    emit signalTerminate();
}

bool SParentProcess::isUserAbort()
{
    return m_bUserAbort;
}


void SParentProcess::setCurrentEffectRow(const SEffectRow& _row)
{
    m_erCurrentRow = _row;
}

void SParentProcess::setCurrentEffectRow(SEffectRow&& _row)
{
    m_erCurrentRow = _row;
    m_erCurrentRow = std::move(_row);
}