DRCEFunctionalObject.cpp

Go to the documentation of this file.

#include <Poco/Environment.h>
#include <Poco/Process.h>
#include <fstream>
#include <iterator>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <utility>

#include "DRCEResultDataSerializator.hpp"
#include "DRCEFunctionalObject.hpp"
#include "DRCEDefaultJSON.hpp"
#include "DRCEFilesList.hpp"
#include "DRCEError.hpp"
#include "ShellExec.hpp"
#include "DRCEMessageConst.hpp"
#include "DRCEEncodeDecodeBase64.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
DRCEFunctionalObject::DRCEFunctionalObject(const std::string& nodeName_, const std::string& homeDir_)
: inherited(), nodeName(nodeName_), homeDir(""), messagesCollection(message_const::messages), message(messagesCollection)
{
  setHomeDir(homeDir_);
}
//-----------------------------------------------------------------------------
bool DRCEFunctionalObject::setHomeDir(const std::string& homeDir_)
{
  resetError();
  if (chdir(homeDir_.c_str())==0)
    homeDir=homeDir_;
  else
  {
    isError(true);
    setErrorCode(ERROR_SET_HOME_DIR);
    setErrorMsg(strerror(errno));
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObject::resetError(void)
{
  isError(false);
  setErrorCode(NO_ERROR);
  setErrorMsg("");
}
//-----------------------------------------------------------------------------
std::string DRCEFunctionalObject::getDefaultJSON(void)
{
  log() << message(message_const::CREATE_DEFAULT_JSON) << std::endl;
  DRCEDefaultJSON defaultJson;
  return defaultJson.getJSON();
}
//-----------------------------------------------------------------------------
std::string DRCEFunctionalObject::Process(const std::string& json)
{
  std::string resJson;
  setErrorCode(NO_ERROR);
  setErrorMsg("");
  try
  {
    DRCEInputJsonMessage inputJsonMessage(json);
    if (inputJsonMessage.isError())
      throw Poco::Exception(inputJsonMessage.getErrorMsg(), PARSE_ERROR);

    DRCEOutputJsonMessage outputMessage = Process(inputJsonMessage);

    outputMessage.setErrorCode(this->getErrorCode());
    outputMessage.setErrorMessage(this->getErrorMsg());

    if (!outputMessage.serialize(resJson))
      throw Poco::Exception(outputMessage.getErrorMsg(), outputMessage.getErrorCode());
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
    log() << message(message_const::ERROR_MSG, errorMsg) << message(message_const::ERROR_CODE, errorCode) << std::endl;
  }
  return (resJson.empty())?getDefaultJSON():resJson;
}
//-----------------------------------------------------------------------------
DRCEOutputJsonMessage DRCEFunctionalObject::Process(DRCEInputJsonMessage& inputJsonMessage)
{
  Poco::Timestamp tsStart;
  DRCEOutputJsonMessage outputMessage;
  DRCEResultDataItem resultDataItem;
  DRCEResultData resultData;

  try
  {
    if (inputJsonMessage.getSessionOptions().sessionType==SessionOptions::SessionType::stHostShell)
    {
      makeProcessHostShell(inputJsonMessage, resultDataItem);
    }
    else if (inputJsonMessage.getSessionOptions().sessionType==SessionOptions::SessionType::stSsh)
    {
      makeProcessSsh(inputJsonMessage, resultDataItem);
    }
    else
    {
      throw Poco::Exception(message(message_const::UNKNOWN_SESSION_TYPE,
          std::to_string(static_cast<unsigned int>(inputJsonMessage.getSessionOptions().sessionType))),
          ERROR_INSTANTIATION_FO);
    }
  }
  catch(Poco::Exception& e)
  {
    isError(true);
    setErrorCode(e.code());
    setErrorMsg(e.message());
  }
  catch(std::exception& e)
  {
    isError(true);
    setErrorCode(ERROR_FUNCTIONAL_OBJECT);
    setErrorMsg(e.what());
  }
  outputMessage.setTime(getElapsedTimeMsec(tsStart));

  const size_t timeInterval = getElapsedTimeMsec(tsStart);
  outputMessage.setTime(timeInterval);
  resultDataItem.setTime(timeInterval);

  resultData.addDataItem(std::forward<DRCEResultDataItem>(resultDataItem));

  std::string resultJson;
  DRCEResultDataSerializator resultDataSerializator(resultData);
  if (!resultDataSerializator.serialize(resultJson))
    throw Poco::Exception(resultDataSerializator.getErrorMsg(), resultDataSerializator.getErrorCode());

  outputMessage.setData(resultJson);

  return outputMessage;
}
//-----------------------------------------------------------------------------
std::string DRCEFunctionalObject::getFullFileName(const std::string& fileName)
{
  std::string result;
  if (fileName.find_last_of('/')==std::string::npos)
    result.append("./").append(fileName);
  else
    result = fileName;

  return result;
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObject::makeFilesBefore(DRCEFilesList& filesList) throw (Poco::Exception)
{
  const size_t filesCount = filesList.getFilesCount();
  for (size_t i=0;i<filesCount;++i)
  {
    const std::string fileName = getFullFileName(filesList.getFileItem(i).name);

    if (((filesList.getFileItem(i).actionType & FileItem::CREATE_BEFORE_EXEC_AND_WRITE_DATA)!=0)==1)
    {
      std::fstream ofs(fileName.c_str(), std::fstream::out|std::fstream::trunc|std::fstream::binary);
      if (!ofs)
        throw Poco::Exception(message(message_const::CREATE_FILE, fileName) , ERROR_CREATE_FILE_BEFORE_EXEC);

      ofs << ((((filesList.getFileItem(i).actionType & FileItem::ENCODE_DECODE_CONTENT_BASE64)!=0)==1)?DRCEDecodeBase64(filesList.getFileItem(i).data):filesList.getFileItem(i).data);
      ofs.close();
    }
    if (((filesList.getFileItem(i).actionType & FileItem::DELETE_BEFORE_EXEC)!=0)==1)
    {
      if (remove(fileName.c_str())!=0)
        throw Poco::Exception(message(message_const::DELETE_FILE, fileName)+
            message(message_const::ERROR, strerror(errno)),
            ERROR_DELETE_FILE_BEFORE_EXEC);
    }
  }
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObject::makeFilesAfter(DRCEFilesList& filesList, DRCEResultDataItem& resultDataItem) throw (Poco::Exception)
{
  const size_t filesCount = filesList.getFilesCount();
  for (size_t i=0;i<filesCount;++i)
  {
    const std::string fileName = getFullFileName(filesList.getFileItem(i).name);

    if (((filesList.getFileItem(i).actionType & FileItem::READ_AFTER_EXEC_AND_RETURN_RESULT)!=0)==1)
    {
      std::ifstream ifs;
      ifs.open(fileName, std::fstream::binary);
      if ( (ifs.rdstate() & std::ifstream::failbit ) != 0 )
        throw Poco::Exception(message(message_const::READ_FILE, fileName), ERROR_READ_FILE_AFTER_EXEC);

      std::string fileContent;
      ifs.seekg(0, std::ios::end);
      fileContent.resize(ifs.tellg());
      ifs.seekg(0, std::ios::beg);
      ifs.read(const_cast<char*>(fileContent.c_str()), fileContent.size());
      ifs.close();

      FileItem fileItem;
      fileItem.actionType = filesList.getFileItem(i).actionType;
      fileItem.name = filesList.getFileItem(i).name;
      fileItem.data = ((((filesList.getFileItem(i).actionType & FileItem::ENCODE_DECODE_CONTENT_BASE64)!=0)==1)?DRCEEncodeBase64(fileContent):fileContent);
      resultDataItem.addFileItem(std::forward<FileItem>(fileItem));
    }
    if (((filesList.getFileItem(i).actionType & FileItem::DELETE_AFTER_EXEC)!=0)==1)
    {
      if (remove(fileName.c_str())!=0)
        throw Poco::Exception(message(message_const::DELETE_FILE, fileName)+
            message(message_const::ERROR, strerror(errno)),
            ERROR_DELETE_FILE_AFTER_EXEC);
    }
  }
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObject::makeSetEnviroment(const std::vector<std::pair<std::string, std::string> >& enviroments) throw (Poco::Exception)
{
  for (size_t i=0;i<enviroments.size();++i)
  {
    if (setenv(enviroments[i].first.c_str(), enviroments[i].second.c_str(), 0)!=0)
      throw Poco::Exception(strerror(errno), ERROR_SET_ENVIRONMENT);
  }
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObject::applyInputStream(std::stringstream& cmd, std::stringstream& istr)
{
  std::istream_iterator<std::string> eos;
  std::istream_iterator<std::string> iit(istr);

  cmd << "echo \"";
  while(iit!=eos)
  {
    cmd << *iit;
    iit++;
    if (iit!=eos)
      cmd << "\n";
  }
  cmd << "\"| ";
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObject::makeProcessHostShell(DRCEInputJsonMessage& inputJsonMessage, DRCEResultDataItem& resultDataItem) throw (Poco::Exception)
{
  makeFilesBefore(inputJsonMessage);

  makeSetEnviroment(inputJsonMessage.getSessionOptions().environments);

  std::stringstream cmd, istr(inputJsonMessage.getInputStream()), ostr, estr;
  if (!istr.str().empty())
  {
    if (inputJsonMessage.getCommandLine().empty())
      throw Poco::Exception(message(message_const::EMPTY_COMMAND_LINE), ERROR_COMMAND_EXECUTION);

    applyInputStream(cmd, istr);
  }

  if (!inputJsonMessage.getCommandLine().empty())
  {
    cmd << inputJsonMessage.getCommandLine();
    log() << message(message_const::COMMAND, cmd.str()) << std::endl;

    ShellExec shellExec(cmd.str());
    if (!shellExec.exec(ostr, estr))
    {
      isError(true);
      setErrorCode(ERROR_COMMAND_EXECUTION);
      setErrorMsg(message(message_const::EXECUTE_COMMAND_FAIL)+
          message(message_const::ERROR, estr.str()));
    }
    resultDataItem.setExitStatus(shellExec.getExitStatus());
  }

  resultDataItem.setStdoutStream(ostr.str());
  resultDataItem.setStderrStream(estr.str());
  resultDataItem.setNodeName(nodeName);

  makeFilesAfter(inputJsonMessage, resultDataItem);
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObject::makeProcessSsh(DRCEInputJsonMessage& inputJsonMessage, DRCEResultDataItem& resultDataItem) throw (Poco::Exception)
{
  // TODO
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace drce
} // namespace HCE