launch_manager.cpp

Go to the documentation of this file.

#include "launch_manager.hpp"
#include "debug.hpp"
 
LaunchManager::~LaunchManager(){
        if(currentLaunch){
                auto& p = currentLaunch->process;
                p.blockSignals(true);
                p.terminate();
                p.waitForFinished(500);
                if(p.state() != QProcess::NotRunning){
                        p.kill();
                        p.waitForFinished(1000);
                }
        }
        queuedLaunch.reset();
}
 
void LaunchManager::launch(std::unique_ptr<LaunchContext>&& ctx){
        if(getCurrentStatus() == LaunchContext::Type::None){
                doLaunch(std::move(ctx));
        } else {
                if(queuedLaunch && queuedLaunch->type == LaunchContext::Type::Run){
                        return;
                }
                queuedLaunch = std::move(ctx);
                currentLaunch->terminate();
        }
}
 
void LaunchManager::doLaunch(std::unique_ptr<LaunchContext>&& ctx){
        currentLaunch = std::move(ctx);
 
        connect(&currentLaunch->process,
                        QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
                        this, &LaunchManager::processFinished, Qt::UniqueConnection);
 
        currentLaunch->process.start(currentLaunch->executablePath, currentLaunch->args);
 
        if(!currentLaunch->process.waitForStarted()){
                //Shouldn't happen as we probe ug executability at startup
                abort_msgBox("Failed to launch process. Did the ug executable disappear?");
        }
}
 
void LaunchManager::stop(){
        if(!currentLaunch)
                return;
 
        currentLaunch->terminate();
}
 
void LaunchManager::processFinished(){
        currentLaunch.reset();
 
        if(queuedLaunch)
                doLaunch(std::move(queuedLaunch));
}
 
std::unique_ptr<LaunchContext> LaunchManager::extractCurrentCtx(){
        auto ret = std::move(currentLaunch);
        return ret;
}
 
 
void LaunchManager::reLaunch(std::unique_ptr<LaunchContext>&& ctx){
        queuedLaunch = std::move(ctx);
}
 
LaunchContext::Type LaunchManager::getCurrentStatus() const{
        if(!currentLaunch)
                return LaunchContext::Type::None;
 
        return currentLaunch->type;
}
 
LaunchContext::LaunchContext(){
        connect(&killTimer, &QTimer::timeout, [=](){ process.kill(); });
        killTimer.setSingleShot(true);
        connect(&process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
                        this, &LaunchContext::processTerminationHandler);
 
        process.setProcessChannelMode(QProcess::MergedChannels);
        connect(&process, &QProcess::readyReadStandardOutput, this, &LaunchContext::processOutput);
        connect(&process, &QProcess::readyReadStandardError, this, &LaunchContext::processOutput);
}
 
void LaunchContext::processTerminationHandler(int code, QProcess::ExitStatus es){
        emit processTerminated(code, es, terminationRequested);
}
 
void LaunchContext::processOutput(){
        QString str = process.isReadable() ? process.readAll() : QByteArray();
 
        emit processOutputRead(str);
 
        lineBuf.write(str.toStdString());
 
        while(lineBuf.hasLine()){
                emit processOutputLine(lineBuf.peek());
                lineBuf.pop();
        }
}
 
void LaunchContext::terminate(){
        terminationRequested = true;
        process.terminate();
        killTimer.start(terminateTimeoutMs);
}