executor.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2016 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef SRC_EXECUTOR_H_
#define SRC_EXECUTOR_H_
 
#include <QObject>
#include <QProcess>
#include <QProcessEnvironment>
#include <QQueue>
#include <atomic>
#include <optional>
#include <utility>

 
class Executor : public QObject {
  Q_OBJECT

  struct ExecQueueItem {
    int id;
    QString app;
    QStringList args;
    QString input;
    bool readStdout;
    bool readStderr;
    QString workingDir;
  };

  QQueue<ExecQueueItem> m_execQueue;
  QProcess m_process;
  bool running{false};
  void executeNext();
  void postDrainedIfIdle();
  int m_pendingErrors = 0;
  bool m_drainCheckPosted = false;
  static void startProcess(QProcess &process, const QString &app,
                           const QStringList &args);
  auto collectOutput(const ExecQueueItem &item, int exitCode)
      -> std::pair<QString, QString>;
  static auto runBlocking(QProcess &process, const QString &app,
                          const QStringList &args, const QString &input,
                          QString *process_out, QString *process_err,
                          const std::atomic_bool *cancel = nullptr,
                          int timeoutMs = -1) -> int;
 
public:
  explicit Executor(QObject *parent = nullptr);

  void execute(int id, const QString &app, const QStringList &args,
               bool readStdout, bool readStderr = true);

  void execute(int id, const QString &workDir, const QString &app,
               const QStringList &args, bool readStdout,
               bool readStderr = true);

  void execute(int id, const QString &app, const QStringList &args,
               QString input = QString(), bool readStdout = false,
               bool readStderr = true);

  void execute(int id, const QString &workDir, const QString &app,
               const QStringList &args, QString input = QString(),
               bool readStdout = false, bool readStderr = true);

  [[nodiscard]] static auto executeBlocking(const QString &app,
                                            const QStringList &args,
                                            const QString &input = QString(),
                                            QString *process_out = nullptr,
                                            QString *process_err = nullptr)
      -> int;

  [[nodiscard]] static auto executeBlocking(
      QProcess &process, const QString &app, const QStringList &args,
      const QString &input = QString(), QString *process_out = nullptr,
      QString *process_err = nullptr, const std::atomic_bool *cancel = nullptr,
      int timeoutMs = -1) -> int;

  [[nodiscard]] static auto
  executeBlocking(const QString &app, const QStringList &args,
                  QString *process_out, QString *process_err = nullptr) -> int;

  [[nodiscard]] static auto
  executeBlocking(const QProcessEnvironment &env, const QString &app,
                  const QStringList &args, QString *process_out = nullptr,
                  QString *process_err = nullptr) -> int;

  static auto resolveExecutable(const QString &app) -> QString;

  static void detachFromTerminal(QProcess &process);

  static void setChildUmask(int mask);

  [[nodiscard]] static auto childUmask() -> int;

  struct WslCommand {
    QString launcher;
    QStringList options;
    QString command;
    auto argv(const QStringList &args) const -> QStringList;
    auto with(const QString &program) const -> WslCommand;
  };

  static auto parseWslCommand(const QString &app) -> std::optional<WslCommand>;

  static auto wslExecArgs(const QString &command, const QStringList &args)
      -> QStringList;

  static auto translatePathForWsl(const QString &path, const QString &exe)
      -> QString;

  void setEnvironment(const QProcessEnvironment &env);
  auto environment() const -> QProcessEnvironment;

  auto cancelNext() -> int;
  auto isIdle() const -> bool { return !running && m_execQueue.isEmpty(); }

  auto hasQueued(int id) const -> bool {
    for (const ExecQueueItem &item : m_execQueue) {
      if (item.id == id) {
        return true;
      }
    }
    return false;
  }
 
private slots:
  void onProcessFinished(int exitCode, QProcess::ExitStatus exitStatus);
signals:
  void drained();
  void finished(int id, int exitCode, const QString &output,
                const QString &errout);
  void starting();
  void dequeuing(int id, bool completes);
  void error(int id, int exitCode, const QString &output,
             const QString &errout);
};
 
#endif // SRC_EXECUTOR_H_