DRCETaskRequestDeleteDataExecutor.cpp

Go to the documentation of this file.

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

#include "DRCEFileExtractor.hpp"
#include "DRCEFileStream.hpp"
#include "DRCEOutputJsonMessage.hpp"
#include "DRCEResultDataSerializator.hpp"

#include "DRCETaskRequestDeleteDataExecutor.hpp"
#include "DRCETaskRequestDeleteData.hpp"

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

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

    const std::string fileName = FileStream::getStatusFileName(nodeOptions.getTasksStatusDir(), pTaskRequestDeleteData->getTaskId());
    try
    {
      if (asyncTaskQueue.isExistAsyncTask(pTaskRequestDeleteData->getTaskId()))
        throw Poco::Exception(message(message_const::TASK_CONTINUES_TO_RUN), ERROR_DELETE_TASK_DATA);

      Poco::File file(fileName);
      if (file.exists())
      {
        DataFileExtractor dataFileExtractor(message);
        DRCEResultDataItem resultItem = dataFileExtractor.extract(fileName);
        resultDataItem.setState(static_cast<unsigned int>(resultItem.getState()));
      }

      if (resultDataItem.getState() == DRCETaskRequest::TaskState::SET_AS_NEW ||
          resultDataItem.getState() == DRCETaskRequest::TaskState::IN_PROGRESS||
          resultDataItem.getState() == DRCETaskRequest::TaskState::QUEUED_TO_RUN)
        throw Poco::Exception(message(message_const::TASK_CONTINUES_TO_RUN), ERROR_DELETE_TASK_DATA);
    }
    catch(Poco::Exception& e)
    {
      Poco::Logger::root().log(Poco::Message(drce_const::moduleName,
          "DRCETaskRequestDeleteData  extract '"+fileName+"' return "+e.message(),
          Poco::Message::Priority::PRIO_DEBUG));
      if (e.code() != ERROR_UNSERIALIZE)
        throw;
    }

    DRCEInputJsonMessage inputMessage = DRCECommonTask::getRequestData(pTaskRequestDeleteData->getTaskId(), nodeOptions, message);
    resultDataItem = DRCECommonTask::makeResultDataItem(inputMessage, nodeOptions, message, DRCETaskRequest::RequestType::rtDeleteTaskData, DRCETaskRequest::TaskState::DELETED);

    DRCECommonTask::SubtasksList subtasks;
    DRCECommonTask::getSubtasksList(inputMessage, subtasks);
    for (DRCECommonTask::SubtasksList::reverse_iterator iter=subtasks.rbegin();iter!=subtasks.rend();++iter)
    {
      DRCECommonTask::cleanup((*iter).first, nodeOptions, message, true);
    }

  }
  catch(Poco::Exception& e)
  {
    resultDataItem.setErrorCode(e.code());
    resultDataItem.setErrorMessage(e.message());
    resultDataItem.setState(static_cast<unsigned int>(DRCETaskRequest::TaskState::CRASHED));
  }
  catch(std::exception& e)
  {
    resultDataItem.setErrorCode(ERROR_EXECUTE_TASK);
    resultDataItem.setErrorMessage(e.what());
    resultDataItem.setState(static_cast<unsigned int>(DRCETaskRequest::TaskState::CRASHED));
  }
  return resultDataItem;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce 
} // end namespace HCE