StarterExecutor.cpp

Go to the documentation of this file.

#include <sys/wait.h>
#include <fstream>

#include <Poco/Thread.h>
#include <Poco/Process.h>
#include <Poco/TemporaryFile.h>

#include "StarterExecutor.hpp"

namespace HCE
{
//-----------------------------------------------------------------------------
StarterExecutor::StarterExecutor(const std::string& homeDir_, const std::string& starterFileName_)
: outPipe(), errPipe(), outInputStream(outPipe), errInputStream(errPipe), outStream(), errStream(),
  starterFileName(""), homeDir(""), inputStreamFileName(""), pid(0), statusExecution(StatusExecution::seUnknown)
{
  setStarterFileName(starterFileName_);
  setHomeDir(homeDir_);
}
//-----------------------------------------------------------------------------
StarterExecutor::~StarterExecutor(void)
{
  Poco::File inputStreamFile(inputStreamFileName);
  if (inputStreamFile.exists())
    inputStreamFile.remove();
}
//-----------------------------------------------------------------------------
void StarterExecutor::setStarterFileName(const std::string& starterFileName_)
{
  starterFileName = (starterFileName_.empty())?starter_const::starterFileName:starterFileName_;
}
//-----------------------------------------------------------------------------
void StarterExecutor::setHomeDir(const std::string& homeDir_)
{
  if (homeDir != homeDir_)
  {
    homeDir=homeDir_;

    Poco::File starterFile(getStarterFullName());
    if (!starterFile.exists())
    {
      Poco::File starterPath = homeDir+starter_const::starterPathName;
      starterPath.createDirectories();

      std::ofstream ofs(starterFile.path().c_str(), std::fstream::trunc);
      ofs << starter_const::starterTemplate;
      ofs.close();

      starterFile.setExecutable(true);
    }
  }
}
//-----------------------------------------------------------------------------
std::string StarterExecutor::getStarterFullName(const std::string& homeDir, const std::string& scriptName)
{
  return homeDir+starter_const::starterPathName+"/"+scriptName;
}
//-----------------------------------------------------------------------------
std::string StarterExecutor::getStarterFullName(void) const
{
  return getStarterFullName(homeDir, starterFileName);
}
//-----------------------------------------------------------------------------
pid_t StarterExecutor::execute(const std::string& cmd, const std::string& inputStream, const Poco::Process::Env& env)
{
  inputStreamFileName = Poco::TemporaryFile::tempName();

  std::fstream fs(inputStreamFileName.c_str(), std::fstream::out|std::fstream::trunc|std::fstream::binary);
  fs << inputStream;
  fs.close();

  Poco::Process::Args args={cmd, inputStreamFileName};
  Poco::ProcessHandle ph = Poco::Process::launch(getStarterFullName(), args, homeDir, 0, &outPipe, &errPipe, env);
  pid = ph.id();

  return pid;
}
//-----------------------------------------------------------------------------
unsigned int StarterExecutor::wait(unsigned int waitTime)
{
  int status = 0;

  /* getting result data */
  outInputStream >> outStream.rdbuf();
  errInputStream >> errStream.rdbuf();

  /* wait process finish */
  statusExecution = StatusExecution::seUnknown;

  waitpid(pid, &status, 0);

//  if (WIFEXITED(status))
//    printf("child status %d\n", WEXITSTATUS(status));
//  else
//    printf("child signal %d\n", WTERMSIG(status));

  if (WIFEXITED(status))
    statusExecution = StatusExecution::seFinished;
  else
    statusExecution = StatusExecution::seTerminated;

  /* getting teil of result data */
  outInputStream >> outStream.rdbuf();
  errInputStream >> errStream.rdbuf();

  /* remove temporary file */
  Poco::File inputStreamFile(inputStreamFileName);
  if (inputStreamFile.exists())
    inputStreamFile.remove();

  /* return exit status */
  return static_cast<unsigned int>(WEXITSTATUS(status));
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool StarterExecutor::isExistShellScript(const std::string& homeDir, const std::string& scriptName)
{
  Poco::File scriptFile(getStarterFullName(homeDir, scriptName));
  return scriptFile.exists();
}
//-----------------------------------------------------------------------------
bool StarterExecutor::canExecuteShellScript(const std::string& homeDir, const std::string& scriptName)
{
  Poco::File scriptFile(getStarterFullName(homeDir, scriptName));
  return scriptFile.canExecute();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace HCE