fc::process Class Reference

start and manage an local process More...

#include <process.hpp>

Inheritance diagram for fc::process:

Collaboration diagram for fc::process:

Classes
class	impl

Public Member Functions
	process ()
	~process ()
virtual iprocess &	exec (const fc::path &exe, std::vector< std::string > args, const fc::path &work_dir=fc::path(), int opts=open_all)
virtual int	result (const microseconds &timeout=microseconds::maximum())
virtual void	kill ()
virtual fc::buffered_ostream_ptr	in_stream ()
	returns a stream that writes to the process' stdin
virtual fc::buffered_istream_ptr	out_stream ()
	returns a stream that reads from the process' stdout
virtual fc::buffered_istream_ptr	err_stream ()
	returns a stream that reads from the process' stderr
Public Member Functions inherited from fc::iprocess
virtual	~iprocess ()

Additional Inherited Members
Public Types inherited from fc::iprocess
enum	exec_opts {   open_none = 0 , open_stdin = 0x01 , open_stdout = 0x02 , open_stderr = 0x04 ,   open_all = open_stdin|open_stdout|open_stderr , suppress_console = 0x08 }

Detailed Description

Note

this class implements reference semantics.

Definition at line 12 of file process.hpp.

Constructor & Destructor Documentation

process()

fc::process::process

(

)

Definition at line 71 of file process.cpp.

:my( new process::impl() ){}

~process()

fc::process::~process

(

)

Definition at line 73 of file process.cpp.

{}

Member Function Documentation

err_stream()

fc::buffered_istream_ptr fc::process::err_stream ( )

virtual

Implements fc::iprocess.

Definition at line 181 of file process.cpp.

                                           {
  return my->_err;
}

exec()

iprocess & fc::process::exec ( const fc::path & exe, std::vector< std::string > args, const fc::path & work_dir = fc::path(), int opts = open_all )

virtual

Returns

*this

Implements fc::iprocess.

Definition at line 75 of file process.cpp.

{
 
  my->pctx.work_dir = work_dir.string();
  my->pctx.suppress_console = (opt & suppress_console) != 0;
    
  if( opt&open_stdout)
      my->pctx.streams[boost::process::stdout_id] = bp::behavior::async_pipe();
  else 
      my->pctx.streams[boost::process::stdout_id] = bp::behavior::null();
 
 
  if( opt& open_stderr )
      my->pctx.streams[boost::process::stderr_id] = bp::behavior::async_pipe();
  else
      my->pctx.streams[boost::process::stderr_id] = bp::behavior::null();
 
  if( opt& open_stdin )
      my->pctx.streams[boost::process::stdin_id]  = bp::behavior::async_pipe();
  else
      my->pctx.streams[boost::process::stdin_id]  = bp::behavior::close();
 
  /*
  std::vector<std::string> a;
  a.reserve(size_t(args.size()));
  for( uint32_t i = 0; i < args.size(); ++i ) {
    a.push_back( fc::move(args[i]) ); 
  }
  */
  my->child.reset( new bp::child( bp::create_child( exe.string(), fc::move(args), my->pctx ) ) );
 
  if( opt & open_stdout ) {
     bp::handle outh = my->child->get_handle( bp::stdout_id );
     my->_outp.reset( new bp::pipe( fc::asio::default_io_service(), outh.release() ) );
  }
  if( opt & open_stderr ) {
     bp::handle errh = my->child->get_handle( bp::stderr_id );
     my->_errp.reset( new bp::pipe( fc::asio::default_io_service(), errh.release() ) );
  }
  if( opt & open_stdin ) {
     bp::handle inh  = my->child->get_handle( bp::stdin_id );
     my->_inp.reset(  new bp::pipe( fc::asio::default_io_service(), inh.release()  ) );
  }
 
 
  promise<int>::ptr p(new promise<int>("process"));
  my->stat.async_wait(  my->child->get_id(), [=]( const boost::system::error_code& ec, int exit_code )
    {
      //slog( "process::result %d", exit_code );
      if( !ec ) {
          #ifdef BOOST_POSIX_API
          if( WIFEXITED(exit_code) ) p->set_value(  WEXITSTATUS(exit_code) );
          else
          {
             p->set_exception( 
                 fc::exception_ptr( new fc::exception( 
                     FC_LOG_MESSAGE( error, "process exited with: ${message} ", 
                                     ("message", strsignal(WTERMSIG(exit_code))) ) ) ) );
          }
          #else
          p->set_value(exit_code);
          #endif
       }
       else
       {
          p->set_exception( 
              fc::exception_ptr( new fc::exception( 
                  FC_LOG_MESSAGE( error, "process exited with: ${message} ", 
                                  ("message", boost::system::system_error(ec).what())) ) ) );
       }
    });
  if( opt & open_stdin )
    my->_in     = std::make_shared<buffered_ostream>(std::make_shared<fc::asio::ostream<bp::pipe>>(my->_inp));
  if( opt & open_stdout )
    my->_out    = std::make_shared<buffered_istream>(std::make_shared<fc::asio::istream<bp::pipe>>(my->_outp));
  if( opt & open_stderr )
    my->_err    = std::make_shared<buffered_istream>(std::make_shared<fc::asio::istream<bp::pipe>>(my->_errp));
  my->_exited = p;
  return *this;
}

Here is the call graph for this function:

in_stream()

fc::buffered_ostream_ptr fc::process::in_stream ( )

virtual

Implements fc::iprocess.

Definition at line 168 of file process.cpp.

                                          {
  return my->_in;
}

kill()

void fc::process::kill ( )

virtual

Forcefully kills the process.

Implements fc::iprocess.

Definition at line 161 of file process.cpp.

                   {
  my->child->terminate();
}

out_stream()

fc::buffered_istream_ptr fc::process::out_stream ( )

virtual

Implements fc::iprocess.

Definition at line 175 of file process.cpp.

                                           {
  return my->_out;
}

result()

int fc::process::result ( const microseconds & timeout = microseconds::maximum() )

virtual

Returns

blocks until the process exits

Implements fc::iprocess.

Definition at line 185 of file process.cpp.

{
    return my->_exited.wait(timeout);
}

---

The documentation for this class was generated from the following files:

• libraries/fc/include/fc/interprocess/process.hpp
• libraries/fc/src/interprocess/process.cpp