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>
#include <utility>
#endif
 
#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::executeNext() {
  if (!running) {
    if (!m_execQueue.isEmpty()) {
      const execQueueItem &i = m_execQueue.head();
      running = true;
      if (!i.workingDir.isEmpty()) {
        m_process.setWorkingDirectory(i.workingDir);
      }
      if (i.app.startsWith("wsl ")) {
        QStringList tmp = i.args;
        QString app = i.app;
        tmp.prepend(app.remove(0, 4));
        m_process.start("wsl", tmp);
      } else {
        m_process.start(i.app, i.args);
      }
      if (!i.input.isEmpty()) {
        m_process.waitForStarted(-1);
        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)
    return out;
  codec = QTextCodec::codecForUtfText(in);
  return codec->toUnicode(in);
#else
  auto converter = QStringDecoder(QStringDecoder::Utf8);
  return converter(in);
#endif
}
 
auto Executor::executeBlocking(QString app, const QStringList &args,
                               const QString &input, QString *process_out,
                               QString *process_err) -> int {
  QProcess internal;
  if (app.startsWith("wsl ")) {
    QStringList tmp = args;
    tmp.prepend(app.remove(0, 4));
    internal.start("wsl", tmp);
  } else {
    internal.start(app, args);
  }
  if (!input.isEmpty()) {
    QByteArray data = input.toUtf8();
    internal.waitForStarted(-1);
    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();
  }
  // TODO(bezet): emit error() ?
  return -1; //    QProcess error code + qDebug error?
}
 
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);
}
 
void Executor::setEnvironment(const QStringList &env) {
  m_process.setEnvironment(env);
}
 
auto Executor::cancelNext() -> int {
  if (running || m_execQueue.isEmpty()) {
    return -1; // TODO(bezet): definitely throw here
  }
  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();
}