DRCEFunctionalObject.hpp

Go to the documentation of this file.

#ifndef DRCE_FUNCTIONAL_OBJECT_HPP
#define DRCE_FUNCTIONAL_OBJECT_HPP

#include <iostream>
#include <vector>

#include "DRCEError.hpp"
#include "DRCEInputJsonMessage.hpp"
#include "DRCEOutputJsonMessage.hpp"
#include "DRCEFunctionalObjectBase.hpp"
#include "DRCENodeOptions.hpp"
#include "DRCEResultData.hpp"
#include "CustomMessage.hpp"
#include "DRCEAsyncTasksQueue.hpp"
#include "DRCEResourceMonitor.hpp"

namespace HCE
{
namespace drce
{
class DRCENotificationExecutor;
//-----------------------------------------------------------------------------
class DRCEFunctionalObject : public DRCEFunctionalObjectBase, public DRCENodeOptions
{
public:
  DRCEFunctionalObject(const std::string& nodeName_, const std::string& homeDir_,
      const std::string& tasksDataDir_, const std::string& tasksStatusDir_,
      const std::string& nodeHost_="", const std::string& nodePort_="");
  virtual ~DRCEFunctionalObject(void);

  std::string Process(const std::string& json);
  DRCEOutputJsonMessage Process(DRCEInputJsonMessage& inputJsonMessage);

  void setNotificationFunctor(std::function<std::string(const std::string&)> notificationFunctor_);
  bool setHomeDir(const std::string& homeDir_);
  void resetError(void);

  void setMaxThreadCount(unsigned int threadCount);
  unsigned int getMaxThreadCount(void) const;
  void saveTaskQueue(void);
  void loadTaskQueue(void);

  void setTasksQueueDumpPeriod(unsigned int periodMs); // period in msec
  unsigned int getTasksQueueDumpPeriod(void);

  void setResourceMonitorTimePeriod(unsigned int timePeriod_);
  unsigned int getResourceMonitorTimePeriod(void);

  void setResetErrorCodeStateNotification(bool resetErrorCodeStateNotification_);
  bool getResetErrorCodeStateNotification(void);

  StatVariables getStatVariables(void);

  typedef std::map<std::string, Poco::Dynamic::Var> Dictionary;
  Dictionary dumpResourceMonitor(void);
  void restoreResourceMonitor(const Dictionary& dictionary);

  size_t getAsyncTasksCount(void);
  bool hasTask(unsigned int taskId);

  size_t getRequestTime(void) const {return requestTime;}
  std::string getCurrentTasksQueue(void);
  std::string getListInfoAllTasks(void);
  std::string getHostResourceUsage(void);

  void setResourceExtractorMaxThreadsCount(size_t maxThreadsCount_);
  size_t getResourceExtractorMaxThreadsCount(void) const;

  void setResourceExtractorMaxProcessesCount(size_t maxProcessesCount_);
  size_t getResourceExtractorMaxProcessesCount(void) const;

  void setResourceExtractorMaxDiskSize(size_t maxDiskSize_);
  size_t getResourceExtractorMaxDiskSize(void) const;

  void setResourceExtractorMaxVramSize(size_t maxVramSize_);
  size_t getResourceExtractorMaxVramSize(void) const;

  void setResourceExtractorMaxRramSize(size_t maxRramSize_);
  size_t getResourceExtractorMaxRramSize(void) const;

  static std::string makeErrorMessage(const std::string& inputMessage, unsigned int state,
      unsigned int errorCode, const std::string& errorMessage);
private:
  std::string getDefaultJSON(const std::string& jsonErrorMessage="", unsigned int jsonErrorCode=NO_ERROR);
  bool process(DRCEInputJsonMessage& inputJsonMessage, DRCEResultDataItem& resultDataItem);
private:
  MessagesCollection messagesCollection;
  CustomMessage message;
  DRCENotificationExecutor notificationExecutor;
  DRCEAsyncTasksQueue asyncTaskQueue;
  DRCEResourceMonitor resourceMonitor;

  size_t requestTime;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace drce
} // namespace HCE

#endif // DRCE_FUNCTIONAL_OBJECT_HPP