DRCETaskRequestCheckStateExecutor.cpp

Go to the documentation of this file.

#include <Poco/Logger.h>
#include <Poco/File.h>

#include "DRCEFileExtractor.hpp"
#include "DRCEFileStream.hpp"
#include "DRCEMessageConst.hpp"
#include "DRCEError.hpp"

#include "DRCETaskRequestCheckStateExecutor.hpp"
#include "DRCETaskRequestCheckState.hpp"
#include "DRCEResourceMonitor.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
DRCETaskRequestCheckStateExecutor::DRCETaskRequestCheckStateExecutor(DRCEAsyncTasksQueue& asyncTaskQueue_,
    DRCENodeOptions& nodeOptions_, CustomMessage& message_, DRCEResourceMonitor& resourceMonitor_)
: inherited(asyncTaskQueue_, nodeOptions_, message_, resourceMonitor_)
{
}
//-----------------------------------------------------------------------------
DRCEResultDataItem DRCETaskRequestCheckStateExecutor::execute(DRCETaskRequest* pTaskRequest, DRCEInputJsonMessage& inputJsonMessage)
{
  DRCEResultDataItem resultDataItem = getResultDataItem(*pTaskRequest, DRCETaskRequest::TaskState::UNDEFINED);

  try
  {
    DRCETaskRequestCheckState* pTaskRequestCheckState = dynamic_cast<DRCETaskRequestCheckState*>(pTaskRequest);
    if (!pTaskRequestCheckState)
      throw Poco::Exception(message(message_const::WRONG_TYPE_TASK_REQUEST), ERROR_BAD_COMMAND_PARAMS);

    if (pTaskRequestCheckState->getCheckType()!=DRCETaskRequestCheckState::CheckType::ctSimple &&
        pTaskRequestCheckState->getCheckType()!=DRCETaskRequestCheckState::CheckType::ctExtended)
      throw Poco::Exception(message(message_const::WRONG_CHECK_TYPE, static_cast<unsigned int>(pTaskRequestCheckState->getCheckType())), ERROR_BAD_COMMAND_PARAMS);

    std::string fileName;
    if (pTaskRequestCheckState->getCheckType()==DRCETaskRequestCheckState::CheckType::ctExtended)
    {
      // data file name
      fileName =  FileStream::getDataFileName(nodeOptions.getTasksDataDir(), pTaskRequestCheckState->getTaskId());
    }
    else
    {
      // status file name
      fileName = FileStream::getStatusFileName(nodeOptions.getTasksStatusDir(), pTaskRequestCheckState->getTaskId());
    }

    Poco::File fileSource(fileName);
    if (!fileSource.exists())
    {
      resultDataItem.setState(static_cast<unsigned int>(DRCETaskRequest::TaskState::NOT_FOUND));
      throw Poco::Exception(message(message_const::TASK_DATA_NOT_FOUND), ERROR_EXECUTE_TASK);
    }

    resultDataItem.setState(static_cast<unsigned int>(DRCETaskRequest::TaskState::BUSY));

    if (asyncTaskQueue.isLockedAsyncTask(resultDataItem.getRequestId()))
    {
      Poco::Thread::sleep(500);
      if (asyncTaskQueue.isLockedAsyncTask(resultDataItem.getRequestId()))
      {
        throw Poco::Exception(message(message_const::TASK_BUSY), ERROR_CHECK_STATE_BUSY_TASK);
      }
    }

    AsyncTaskLocker lock(asyncTaskQueue, resultDataItem.getRequestId());
    DataFileExtractor dataFileExtractor(message);
    for (size_t i=0;i<HCE::drce::drce_const::REPEAT_TRY_READ_DATA_FILE;++i)
    {
      try
      {
        resultDataItem = dataFileExtractor.extract(fileName);
        break;
      }
      catch(Poco::Exception& e)
      {
        Poco::Logger::root().log(Poco::Message(drce_const::moduleName,
            "DRCETaskRequestCheckStateExecutor  extract '"+fileName+"' return "+e.message(),
            Poco::Message::Priority::PRIO_DEBUG));
        if (e.code() != ERROR_UNSERIALIZE)
          throw;
        else
          Poco::Thread::sleep(200);
      }
    }
    DRCEResourceMonitor::fillFieldsArray(resultDataItem, asyncTaskQueue, message, &resourceMonitor);
  }
  catch(Poco::Exception& e)
  {
    resultDataItem.setErrorCode(e.code());
    resultDataItem.setErrorMessage(e.message());
  }
  catch(std::exception& e)
  {
    resultDataItem.setErrorCode(ERROR_EXECUTE_TASK);
    resultDataItem.setErrorMessage(e.what());
  }
  return resultDataItem;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce 
} // end namespace HCE