ExternalProgram.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
 
 
#ifndef ZYPP_EXTERNALPROGRAM_H
#define ZYPP_EXTERNALPROGRAM_H
 
#include <unistd.h>
 
#include <map>
#include <string>
#include <vector>
#include <optional>
 
#include <zypp-core/Globals.h>
#include <zypp-core/base/ExternalDataSource.h>
#include <zypp-core/Pathname.h>
 
namespace zyppng {
  class AbstractSpawnEngine;
}
 
namespace zypp {

     */
    class ZYPP_API ExternalProgram : public zypp::externalprogram::ExternalDataSource
    {
 
    public:
 
      using Arguments = std::vector<std::string>;

       */
      enum Stderr_Disposition {
        Normal_Stderr,
        Discard_Stderr,
        Stderr_To_Stdout,
        Stderr_To_FileDesc
      };

      using Environment = std::map<std::string, std::string>;

      ExternalProgram (const std::string& commandline,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");

 
      ExternalProgram();
 
      ExternalProgram (const Arguments &argv,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");
 
      ExternalProgram (const Arguments &argv, const Environment & environment,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");
 
      ExternalProgram (const char *const *argv,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");
 
      ExternalProgram (const char *const *argv, const Environment & environment,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");
 
      ExternalProgram (const char *binpath, const char *const *argv_1,
                     bool use_pty = false);
 
 
      ExternalProgram (const char *binpath, const char *const *argv_1, const Environment & environment,
                     bool use_pty = false);
 
 
      ~ExternalProgram() override;
 
#ifdef __cpp_lib_optional // YAST/PK explicitly use c++11 until 15-SP3
      bool waitForExit ( std::optional<uint64_t> timeout = {} );
#endif

      int close() override;

      bool kill();

      bool kill( int sig );

      bool running();

      Pathname chroot() const;

      pid_t getpid();

      const std::string & command() const;

      const std::string & execError() const;

      static void renumber_fd (int origfd, int newfd);
 
    public:

      std::ostream & operator>>( std::ostream & out_r );
 
    private:
      std::unique_ptr<zyppng::AbstractSpawnEngine> _backend;
 
    protected:
 
      void start_program (const char *const *argv, const Environment & environment,
                        Stderr_Disposition stderr_disp = Normal_Stderr,
                        int stderr_fd = -1, bool default_locale = false,
                        const char* root = NULL, bool switch_pgid = false, bool die_with_parent = false, bool usePty = false );
 
    };
 
 
  namespace externalprogram
  {
     */
    struct EarlyPipe
    {
      enum { R=0, W=1 };
      EarlyPipe();
      ~EarlyPipe();
      void closeW()               { if ( _fds[W] != -1 ) { ::close( _fds[W] ); _fds[W] = -1; } }
      FILE * fStdErr()           { return _stderr; }
      protected:
        FILE * _stderr;
        int _fds[2];
    };
  } // namespace externalprogram

   */
  class ExternalProgramWithStderr : private externalprogram::EarlyPipe, public ExternalProgram
  {
    public:
      ExternalProgramWithStderr( const Arguments & argv_r, bool defaultLocale_r = false, const Pathname & root_r = "" )
      : ExternalProgram( argv_r, Stderr_To_FileDesc, /*use_pty*/false, _fds[W], defaultLocale_r, root_r )
      { _initStdErr(); }
      /** \overlocad Convenience taking just the \a root_r. */
      ExternalProgramWithStderr( const Arguments & argv_r, const Pathname & root_r )
      : ExternalProgramWithStderr( argv_r, false, root_r )
      {}
 
      ExternalProgramWithStderr( const Arguments & argv_r, const Environment & environment_r, bool defaultLocale_r = false, const Pathname & root_r = "" )
      : ExternalProgram( argv_r, environment_r, Stderr_To_FileDesc, /*use_pty*/false, _fds[W], defaultLocale_r, root_r )
      { _initStdErr(); }
      /** \overlocad Convenience taking just the \a root_r.  */
      ExternalProgramWithStderr( const Arguments & argv_r, const Environment & environment_r, const Pathname & root_r )
      : ExternalProgramWithStderr( argv_r, environment_r, false, root_r )
      {}
  public:
      using externalprogram::EarlyPipe::fStdErr;

      bool stderrGetUpTo( std::string & retval_r, const char delim_r, bool returnDelim_r = false );

       */
      bool stderrGetline( std::string & retval_r, bool returnDelim_r = false  )
      { return stderrGetUpTo( retval_r, '\n', returnDelim_r ); }
 
    private:
      /** Close write end of the pipe (childs end). */
      void _initStdErr()
      { closeW(); }
 
    private:
      std::string _buffer;
  };

   */
  class ExternalProgramWithSeperatePgid : public ExternalProgram
  {
    public:
      ExternalProgramWithSeperatePgid (const char *const *argv,
                   Stderr_Disposition stderr_disp = Normal_Stderr,
                   int stderr_fd = -1, bool default_locale = false,
                   const Pathname& root = "") : ExternalProgram()
      {
        start_program( argv, Environment(), stderr_disp, stderr_fd, default_locale, root.c_str(), true );
      }
 
  };
 
} // namespace zypp
 
#endif // ZYPP_EXTERNALPROGRAM_H