Process.h

/* miktex/Core/Process.h:                               -*- C++ -*-
 
   Copyright (C) 1996-2021 Christian Schenk
 
   This file is part of the MiKTeX Core Library.
 
   The MiKTeX Core Library is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2, or
   (at your option) any later version.
 
   The MiKTeX Core Library is distributed in the hope that it will be
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with the MiKTeX Core Library; if not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA. */
 
#pragma once
 
#if !defined(B7FD926CACF346B0BA927D19810BDA19)
#define B7FD926CACF346B0BA927D19810BDA19
 
#include <miktex/Core/config.h>
 
#include <cstddef>
#include <cstdint>
#include <cstdio>
 
#include <algorithm>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include <miktex/Util/PathName>
 
#include "Exceptions.h"
 
MIKTEX_CORE_BEGIN_NAMESPACE;

class MIKTEXNOVTABLE IRunProcessCallback
{
public:
  virtual bool MIKTEXTHISCALL OnProcessOutput(const void* output, std::size_t n) = 0;
 
#if 0
public:
  virtual bool MIKTEXTHISCALL OnProcessError(const void* error, std::size_t n) = 0;
#endif
};

template<std::size_t MaxStdoutSize_ = 1024, std::size_t ExpectedStdoutSize_ = 1024> class ProcessOutput :
  public IRunProcessCallback
{
public:
  ProcessOutput() :
    stdoutBytes(ExpectedStdoutSize_)
  {
  }
 
public:
  bool MIKTEXTHISCALL OnProcessOutput(const void* bytes, std::size_t nBytes) override
  {
#if defined(_MSC_VER)
#pragma push_macro("min")
#undef min
#endif
    std::size_t n = std::min(nBytes, MaxStdoutSize_ - stdoutOffset);
#if defined(MIKTEX_WINDOWS)
#pragma pop_macro("min")
#endif
    if (n > 0)
    {
      stdoutBytes.reserve(stdoutOffset + n);
      std::copy(reinterpret_cast<const uint8_t*>(bytes), reinterpret_cast<const uint8_t*>(bytes) + n, stdoutBytes.data() + stdoutOffset);
      stdoutOffset += n;
    }
    return true;
  }

public:
  std::vector<uint8_t> GetStandardOutput() const
  {
    return stdoutBytes;
  }

public:
  std::string StdoutToString() const
  {
    // FIXME: assume UTF-8
    std::string result;
    result.reserve(stdoutOffset);
    result.assign(reinterpret_cast<const char*>(stdoutBytes.data()), reinterpret_cast<const char*>(stdoutBytes.data() + stdoutOffset));
    return result;
  }
 
private:
  std::vector<uint8_t> stdoutBytes;
 
private:
  std::size_t stdoutOffset = 0;
};

struct ProcessStartInfo
{
  std::vector<std::string> Arguments;

  std::string FileName;
 
#if defined(MIKTEX_WINDOWS)
  FILE* StandardError = nullptr;
#endif

  FILE* StandardInput = nullptr;
 
#if defined(MIKTEX_WINDOWS)
  FILE* StandardOutput = nullptr;
#endif

  bool RedirectStandardError = false;

  bool RedirectStandardInput = false;

  bool RedirectStandardOutput = false;

  std::string WorkingDirectory;
  
  bool Daemonize = false;
 
  ProcessStartInfo()
  {
  }
 
  ProcessStartInfo(const MiKTeX::Util::PathName& fileName) :
    FileName(fileName.ToString())
  {
  }
};

enum class ProcessStatus
{
  None,
  Runnable,
  Sleeping,
  Stopped,
  Zombie,
  Other
};

enum class ProcessExitStatus
{
  None,
  Exited,
  Signaled,
  Other
};

struct ProcessInfo
{
  std::string name;
  ProcessStatus status = ProcessStatus::None;
  int parent = -1;
};

class MIKTEXNOVTABLE Process
{
public:
  virtual MIKTEXTHISCALL ~Process() noexcept = 0;

public:
  virtual FILE* MIKTEXTHISCALL get_StandardInput() = 0;

public:
  virtual FILE* MIKTEXTHISCALL get_StandardOutput() = 0;

public:
  virtual FILE* MIKTEXTHISCALL get_StandardError() = 0;

public:
  virtual void MIKTEXTHISCALL WaitForExit() = 0;

public:
  virtual bool MIKTEXTHISCALL WaitForExit(int milliseconds) = 0;

public:
  virtual ProcessExitStatus MIKTEXTHISCALL get_ExitStatus() const = 0;

public:
  virtual int MIKTEXTHISCALL get_ExitCode() const = 0;

public:
  virtual bool MIKTEXTHISCALL get_Exception(MiKTeX::Core::MiKTeXException& ex) const = 0;

public:
  virtual void MIKTEXTHISCALL Close() = 0;

public:
  virtual int MIKTEXTHISCALL GetSystemId() = 0;

public:
  virtual std::unique_ptr<Process> MIKTEXTHISCALL get_Parent() = 0;

public:
  virtual std::string MIKTEXTHISCALL get_ProcessName() = 0;

public:
  virtual ProcessInfo MIKTEXTHISCALL GetProcessInfo() = 0;

public:
  static MIKTEXCORECEEAPI(std::unique_ptr<Process>) GetCurrentProcess();

public:
  static MIKTEXCORECEEAPI(std::unique_ptr<Process>) GetProcess(int systemId);

public:
  static MIKTEXCORECEEAPI(std::vector<std::string>) GetInvokerNames();

public:
  static MIKTEXCORECEEAPI(std::unique_ptr<Process>) StartSystemCommand(const std::string& commandLine, FILE** ppFileStandardInput, FILE** ppFileStandardOutput);

public:
  static void StartSystemCommand(const std::string& commandLine)
  {
    auto process = StartSystemCommand(commandLine, nullptr, nullptr);
    process->Close();
  }

public:
  static MIKTEXCORECEEAPI(bool) ExecuteSystemCommand(const std::string& commandLine);

public:
  static MIKTEXCORECEEAPI(bool) ExecuteSystemCommand(const std::string& commandLine, int* exitCode);

public:
  static MIKTEXCORECEEAPI(bool) ExecuteSystemCommand(const std::string& commandLine, int* exitCode, IRunProcessCallback* callback, const char* workingDirectory);

public:
  static MIKTEXCORECEEAPI(void) Run(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments);

public:
  static void Run(const MiKTeX::Util::PathName& fileName)
  {
    Run(fileName, std::vector<std::string>{ fileName.ToString() });
  }

public:
  static MIKTEXCORECEEAPI(void) Run(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments, IRunProcessCallback* callback);

public:
  static MIKTEXCORECEEAPI(bool) Run(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments, IRunProcessCallback* callback, int* exitCode, MiKTeXException* miktexException, const char* workingDirectory);

public:
  static MIKTEXCORECEEAPI(bool) Run(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments, std::function<bool(const void*, std::size_t)> callback, int* exitCode, MiKTeXException* miktexException, const char* workingDirectory);

public:
  static bool Run(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments, IRunProcessCallback* callback, int* exitCode, const char* workingDirectory)
  {
    return Run(fileName, arguments, callback, exitCode, nullptr, workingDirectory);
  }

public:
  static MIKTEXCORECEEAPI(std::unique_ptr<Process>) Start(const ProcessStartInfo& startinfo);

public:
  static MIKTEXCORECEEAPI(void) Start(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments, FILE* pFileStandardInput, FILE** ppFileStandardInput, FILE** ppFileStandardOutput, FILE** ppFileStandardError, const char* workingDirectory);

public:
  static void Start(const MiKTeX::Util::PathName& fileName)
  {
    Start(fileName, std::vector<std::string>{ fileName.GetFileNameWithoutExtension().ToString() }, nullptr, nullptr, nullptr, nullptr, nullptr);
  }

public:
  static void Start(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments)
  {
    Start(fileName, arguments, nullptr, nullptr, nullptr, nullptr, nullptr);
  }
 
public:
  static MIKTEXCORECEEAPI(void) Overlay(const MiKTeX::Util::PathName& fileName, const std::vector<std::string>& arguments);
};
 
MIKTEX_CORE_END_NAMESPACE;
 
#endif