BOL::WaitingOnSubprocessExecutor Class Reference

#include <WaitingOnSubprocessExecutor.hpp>

Detailed Description

Definition at line 26 of file WaitingOnSubprocessExecutor.hpp.

Public Member Functions
bool	forkAndExecvAndWait ()
void	setArguments (std::string const &argumentsAsSingleString)
void	setExecutableName (std::string const &executableName)
void	setPatienceTicks (int const patienceTicks)
	WaitingOnSubprocessExecutor (std::string const &executableStringIncludingArguments, bool const isVerbose, int const patienceMilliseconds=10000)
	~WaitingOnSubprocessExecutor ()

Protected Member Functions
void	setUpArgumentCharArray ()

Protected Attributes
char const **	argumentListAsArray
VectorlikeArray< std::string >	executableNameAndArguments
bool const	isVerbose
clock_t	killingTime
clock_t	patienceTicks
int	processId

Static Protected Attributes
static int const	sleepingMicroseconds

Constructor & Destructor Documentation

WaitingOnSubprocessExecutor()

BOL::WaitingOnSubprocessExecutor::WaitingOnSubprocessExecutor	(	std::string const &	executableStringIncludingArguments,
		bool const	isVerbose,
		int const	patienceMilliseconds = 10000
	)

Definition at line 19 of file WaitingOnSubprocessExecutor.cpp.

                                                                              :
      processId( 0 ),
      isVerbose( isVerbose ),
      executableNameAndArguments( 0 ),
      argumentListAsArray( NULL ),
      patienceTicks( ( ( patienceMilliseconds * CLOCKS_PER_SEC ) / 1000 ) ),
      killingTime()
  {
    StringParser::parseByChar( executableStringIncludingArguments,
                               executableNameAndArguments );
    setUpArgumentCharArray();
  }

~WaitingOnSubprocessExecutor()

BOL::WaitingOnSubprocessExecutor::~WaitingOnSubprocessExecutor

(

)

Definition at line 35 of file WaitingOnSubprocessExecutor.cpp.

  {
    delete[] argumentListAsArray;
  }

Member Function Documentation

forkAndExecvAndWait()

bool BOL::WaitingOnSubprocessExecutor::forkAndExecvAndWait

(

)

Definition at line 42 of file WaitingOnSubprocessExecutor.cpp.

  {
    killingTime = ( clock() + patienceTicks );
    int processStatus( 0 );
    // this keeps track of the status of the process.
    int returnValue( 0 );
    // this keeps track of what processes return.
    bool subprocessReturned( true );
    // assume that the subprocess won't have to be killed.
    int forkReturnValue( fork() );
    if( 0 > forkReturnValue )
      // if fork failed to do what it should do...
    {
      std::cout
      << std::endl
      << "BOL::error! WaitingOnSubprocessExecutor::forkAndExecvAndWait() was"
      << " unable to create the subprocess; there was an error and fork()"
      << " returned " << forkReturnValue << std::endl;
      // print error message.
    }
    else if( 0 == forkReturnValue )
      // otherwise if this is the subprocess
      // [since it got the 0 from fork()]...
    {
      processId = getpid();
      if( isVerbose )
      {
        std::cout
        << std::endl
        << "now executing \"" << argumentListAsArray[ 0 ];
        for( int argumentWritingCounter( 1 );
             executableNameAndArguments.getSize() > argumentWritingCounter;
             ++argumentWritingCounter )
        {
          std::cout
          << " " << argumentListAsArray[ argumentWritingCounter ];
        }
        std::cout
        << "\", with process id " << getpid() << ", real user id " << getuid()
        << " & effective user id " << geteuid() << std::endl;
      }
      returnValue = execv( argumentListAsArray[ 0 ],
                           (char* const*)argumentListAsArray );
      // run the executable with its arguments.
      exit( returnValue );
    }
    else if( 0 < forkReturnValue )
      // otherwise this is the parent process, since it got given the process
      // id of the subprocess.
    {
      bool subprocessFinished( false );
      // the tracker of whether the subprocess has changed state or not.
      while( clock() < killingTime )
      {
        if( waitpid( forkReturnValue,
                     &processStatus,
                     WNOHANG ) == forkReturnValue )
          /* if the waitpid() function waited for the subprocess (with
           * process id fork_return) and the subprocess changed state, so
           * that waitpid() returned the subprocess's process id...
           */
        {
          killingTime = clock() - 1;
          // note that we don't have to wait any more.
          subprocessFinished = true;
          // note that the subprocess changed state.
        }
        else
        {
          usleep( sleepingMicroseconds );
          // wait 1000 microseconds = 1 millisecond.
        }
      }
      if( false == subprocessFinished )
        // if we have waited over (patienceTicks/1000) seconds & the
        // subprocess has not changed state...
      {
        if( isVerbose )
        {
          std::cout
          << std::endl
          << "killing forked process " << forkReturnValue
          << " due to it taking over " << patienceTicks << " milliseconds"
          << std::endl;
          // print warning about hanging subprocess.
        }
        kill( forkReturnValue,
              9 );
        // kill the hanging process.
        waitpid( -1,
                 &processStatus,
                 0 );
        // wait for all this killing to finish?  I'm not entirely sure.
        subprocessReturned = false;
        // note that the subprocess had to be killed because it did not
        // return a value.
      }
      returnValue = WEXITSTATUS( processStatus );
    }  // end of fork() statement.
    return subprocessReturned;
  }

setArguments()

void BOL::WaitingOnSubprocessExecutor::setArguments ( std::string const &  argumentsAsSingleString )

inline

Definition at line 95 of file WaitingOnSubprocessExecutor.hpp.

  {
    executableNameAndArguments.setSize( 1 );
    StringParser::parseByChar( argumentsAsSingleString,
                               executableNameAndArguments );
    setUpArgumentCharArray();
  }

setExecutableName()

void BOL::WaitingOnSubprocessExecutor::setExecutableName ( std::string const &  executableName )

inline

Definition at line 80 of file WaitingOnSubprocessExecutor.hpp.

  {
    executableNameAndArguments.getFront().assign( executableName );
    setUpArgumentCharArray();
  }

setPatienceTicks()

void BOL::WaitingOnSubprocessExecutor::setPatienceTicks ( int const  patienceTicks )

inline

Definition at line 88 of file WaitingOnSubprocessExecutor.hpp.

  {
    this->patienceTicks = patienceTicks;
  }

setUpArgumentCharArray()

void BOL::WaitingOnSubprocessExecutor::setUpArgumentCharArray ( )

inlineprotected

Definition at line 110 of file WaitingOnSubprocessExecutor.hpp.

  {
    delete[] argumentListAsArray;
    argumentListAsArray
    = new char const*[ ( executableNameAndArguments.getSize() + 1 ) ];
    // create a char* const array which has room for the executable name,
    // then all the arguments, then NULL.
    for( int argumentCharArrayCounter( 0 );
         executableNameAndArguments.getSize() > argumentCharArrayCounter;
         ++argumentCharArrayCounter )
      // go through the list of arguments.
    {
      argumentListAsArray[ argumentCharArrayCounter ]
      = executableNameAndArguments[ argumentCharArrayCounter ].c_str();
      // write this argument as the (argumentCharArrayCounter)th element.
    }
    argumentListAsArray[ executableNameAndArguments.getSize() ] = NULL;
    // we fill the (argumentCharArrayCounter + 1)th element with NULL, since
    // that is what execv() wants.
  }

Member Data Documentation

argumentListAsArray

char const** BOL::WaitingOnSubprocessExecutor::argumentListAsArray

protected

Definition at line 59 of file WaitingOnSubprocessExecutor.hpp.

executableNameAndArguments

VectorlikeArray< std::string > BOL::WaitingOnSubprocessExecutor::executableNameAndArguments

protected

Definition at line 58 of file WaitingOnSubprocessExecutor.hpp.

isVerbose

bool const BOL::WaitingOnSubprocessExecutor::isVerbose

protected

Definition at line 56 of file WaitingOnSubprocessExecutor.hpp.

killingTime

clock_t BOL::WaitingOnSubprocessExecutor::killingTime

protected

Definition at line 69 of file WaitingOnSubprocessExecutor.hpp.

patienceTicks

clock_t BOL::WaitingOnSubprocessExecutor::patienceTicks

protected

Definition at line 64 of file WaitingOnSubprocessExecutor.hpp.

processId

int BOL::WaitingOnSubprocessExecutor::processId

protected

Definition at line 53 of file WaitingOnSubprocessExecutor.hpp.

sleepingMicroseconds

int const BOL::WaitingOnSubprocessExecutor::sleepingMicroseconds

staticprotected

Definition at line 51 of file WaitingOnSubprocessExecutor.hpp.

---

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

• WaitingOnSubprocessExecutor.hpp
• WaitingOnSubprocessExecutor.cpp