executor.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2016 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#include "executor.h"
#include <QCoreApplication>
#include <QDir>
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
#include <QTextCodec>
#endif
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
#include <QStringDecoder>
#endif
#include <utility>
 
#ifdef QT_DEBUG
#include "debughelper.h"
#endif

Executor::Executor(QObject *parent) : QObject(parent), running(false) {
  connect(&m_process,
          static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(
              &QProcess::finished),
          this,
          static_cast<void (Executor::*)(int, QProcess::ExitStatus)>(
              &Executor::finished));
  connect(&m_process, &QProcess::started, this, &Executor::starting);
}

void Executor::startProcess(const QString &app, const QStringList &args) {
  if (app.startsWith("wsl ")) {
    QStringList wslArgs = args;
    QString actualApp = app;
    wslArgs.prepend(actualApp.remove(0, 4));
    m_process.start("wsl", wslArgs);
  } else {
    m_process.start(app, args);
  }
}

void Executor::startProcessBlocking(QProcess &internal, const QString &app,
                                    const QStringList &args) {
  if (app.startsWith("wsl ")) {
    QStringList wslArgs = args;
    QString actualApp = app;
    wslArgs.prepend(actualApp.remove(0, 4));
    internal.start("wsl", wslArgs);
  } else {
    internal.start(app, args);
  }
}

void Executor::executeNext() {
  if (!running) {
    if (!m_execQueue.isEmpty()) {
      const execQueueItem &i = m_execQueue.head();
      running = true;
      if (!i.workingDir.isEmpty()) {
        m_process.setWorkingDirectory(i.workingDir);
      }
      startProcess(i.app, i.args);
      if (!i.input.isEmpty()) {
        if (!m_process.waitForStarted(-1)) {
#ifdef QT_DEBUG
          dbg() << "Process failed to start:" << i.id << " " << i.app;
#endif
          m_process.closeWriteChannel();
          running = false;
          m_execQueue.dequeue();
          executeNext();
          return;
        }
        QByteArray data = i.input.toUtf8();
        if (m_process.write(data) != data.length()) {
#ifdef QT_DEBUG
          dbg() << "Not all data written to process:" << i.id << " " << i.app;
#endif
        }
      }
      m_process.closeWriteChannel();
    }
  }
}

void Executor::execute(int id, const QString &app, const QStringList &args,
                       bool readStdout, bool readStderr) {
  execute(id, QString(), app, args, QString(), readStdout, readStderr);
}

void Executor::execute(int id, const QString &workDir, const QString &app,
                       const QStringList &args, bool readStdout,
                       bool readStderr) {
  execute(id, workDir, app, args, QString(), readStdout, readStderr);
}

void Executor::execute(int id, const QString &app, const QStringList &args,
                       QString input, bool readStdout, bool readStderr) {
  execute(id, QString(), app, args, std::move(input), readStdout, readStderr);
}

void Executor::execute(int id, const QString &workDir, const QString &app,
                       const QStringList &args, QString input, bool readStdout,
                       bool readStderr) {
  // Happens a lot if e.g. git binary is not set.
  // This will result in bogus "QProcess::FailedToStart" messages,
  // also hiding legitimate errors from the gpg commands.
  if (app.isEmpty()) {
#ifdef QT_DEBUG
    dbg() << "Trying to execute nothing...";
#endif
    return;
  }
  QString appPath = app;
  if (!appPath.startsWith("wsl ")) {
    appPath =
        QDir(QCoreApplication::applicationDirPath()).absoluteFilePath(app);
  }
  m_execQueue.push_back(
      {id, appPath, args, std::move(input), readStdout, readStderr, workDir});
  executeNext();
}

static auto decodeAssumingUtf8(const QByteArray &in) -> QString {
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
  QTextCodec *codec = QTextCodec::codecForName("UTF-8");
  QTextCodec::ConverterState state;
  QString out = codec->toUnicode(in.constData(), in.size(), &state);
  if (state.invalidChars == 0) {
    return out;
  }
  codec = QTextCodec::codecForUtfText(in);
  return codec->toUnicode(in);
#else
  auto converter = QStringDecoder(QStringDecoder::Utf8);
  QString out = converter(in);
  if (!converter.hasError()) {
    return out;
  }
  // Fallback if UTF-8 decoding failed - try system encoding
  auto fallback = QStringDecoder(QStringDecoder::System);
  return fallback(in);
#endif
}

auto Executor::executeBlocking(QString app, const QStringList &args,
                               const QString &input, QString *process_out,
                               QString *process_err) -> int {
  QProcess internal;
  startProcessBlocking(internal, app, args);
  if (!internal.waitForStarted(-1)) {
#ifdef QT_DEBUG
    dbg() << "Process failed to start:" << app;
#endif
    return -1;
  }
  if (!input.isEmpty()) {
    QByteArray data = input.toUtf8();
    if (internal.write(data) != data.length()) {
#ifdef QT_DEBUG
      dbg() << "Not all input written:" << app;
#endif
    }
    internal.closeWriteChannel();
  }
  internal.waitForFinished(-1);
  if (internal.exitStatus() == QProcess::NormalExit) {
    QString pout = decodeAssumingUtf8(internal.readAllStandardOutput());
    QString perr = decodeAssumingUtf8(internal.readAllStandardError());
    if (process_out != nullptr) {
      *process_out = pout;
    }
    if (process_err != nullptr) {
      *process_err = perr;
    }
    return internal.exitCode();
  }
  // Process failed to start or crashed; return -1 to indicate error.
  // The calling code checks for non-zero exit codes for error handling.
  return -1;
}

auto Executor::executeBlocking(QString app, const QStringList &args,
                               QString *process_out, QString *process_err)
    -> int {
  return executeBlocking(std::move(app), args, QString(), process_out,
                         process_err);
}

auto Executor::executeBlocking(const QStringList &env, QString app,
                               const QStringList &args, QString *process_out,
                               QString *process_err) -> int {
  QProcess process;
  QProcessEnvironment penv;
  for (const QString &var : env) {
    int idx = var.indexOf('=');
    if (idx > 0) {
      penv.insert(var.left(idx), var.mid(idx + 1));
    }
  }
  process.setProcessEnvironment(penv);
  startProcessBlocking(process, app, args);
  if (!process.waitForStarted(-1)) {
#ifdef QT_DEBUG
    dbg() << "Process failed to start:" << app;
#endif
    return -1;
  }
  process.waitForFinished(-1);
  if (process.exitStatus() != QProcess::NormalExit) {
    return -1;
  }
  if (process_out) {
    *process_out = decodeAssumingUtf8(process.readAllStandardOutput());
  }
  if (process_err) {
    *process_err = decodeAssumingUtf8(process.readAllStandardError());
  }
  return process.exitCode();
}

void Executor::setEnvironment(const QStringList &env) {
  m_process.setEnvironment(env);
}

auto Executor::cancelNext() -> int {
  if (running || m_execQueue.isEmpty()) {
    return -1; // Return -1 to indicate no process was cancelled
               // (queue empty or currently executing).
  }
  return m_execQueue.dequeue().id;
}

void Executor::finished(int exitCode, QProcess::ExitStatus exitStatus) {
  execQueueItem i = m_execQueue.dequeue();
  running = false;
  if (exitStatus == QProcess::NormalExit) {
    QString output;
    QString err;
    if (i.readStdout) {
      output = decodeAssumingUtf8(m_process.readAllStandardOutput());
    }
    if (i.readStderr || exitCode != 0) {
      err = decodeAssumingUtf8(m_process.readAllStandardError());
      if (exitCode != 0) {
#ifdef QT_DEBUG
        dbg() << exitCode << err;
#endif
      }
    }
    emit finished(i.id, exitCode, output, err);
  }
  //  else: emit crashed with ID, which may give a chance to recover ?
  executeNext();
}