DRCEMessageConst.hpp

Go to the documentation of this file.

#ifndef DRCE_MESSAGE_CONST_HPP
#define DRCE_MESSAGE_CONST_HPP

#include <vector>
#include <string>

namespace HCE
{
namespace drce
{
namespace message_const
{
//-----------------------------------------------------------------------------
  enum
  {
    CREATE_DEFAULT_JSON=0,
    SERIALIZATION_OUTPUT_JSON_MESSAGE_ERROR,
    EMPTY_COMMAND_LINE,
    EXECUTE_COMMAND_FAIL,
    UNKNOWN_SESSION_TYPE,
    OBJECT_INSTANCE_WAS_NOT_CREATED,
    EMPTY_OBJECT_INSTANCE,
    SET_HOME_DIR,
    ERROR,
    ERROR_MSG,
    ERROR_CODE,
    COMMAND,
    CREATE_FILE,
    READ_FILE,
    DELETE_FILE,
    ERROR_READ_DATA_FILE,
    ERROR_READ_REQUEST_FILE,
    NOT_EXISTS_DATA_FILE,
    NOT_EXISTS_REQUEST_FILE,
    ERROR_EXECUTE_NOTIFICATION,
    BAD_FILE_CONTENT,
    SHELL_SCRIPT_NOT_EXIST,
    SHELL_SCRIPT_CANNOT_EXECUTE,
    WRONG_TYPE_TASK_REQUEST,
    WRONG_TYPE_THREAD_MODE,
    EXECUTE_SHELL_HOST_COMMAND_FAIL,
    SHELL_HOST_COMMAND_RETURN_ERROR,
    WRONG_TYPE_REMOTE_EXCUTION,
    TASK_CONTINUES_TO_RUN,
    WRONG_CHECK_TYPE,
    WRONG_FETCH_TYPE,
    WRONG_ALGORITHM_TYPE,
    BAD_COMMAND_PARAMS,
    BAD_TASK_ID,
    DATA_NOT_RANGE,
    SEARCH_TASK,
    CANCEL_TASK,
    INVALID_PID_PROCESS,
    TASK_NOT_FOUND,
    TASK_DATA_NOT_FOUND,
    PROCESS_WAS_NOT_STOPPED,
    CHANGE_STATE,
    TASK_TIME_EXPIRED,
    TASK_CANCELED,
    EXCEEDED_CPU_LOAD,
    EXCEEDED_IOWAIT_LOAD,
    PRESENT_LOADING,
    EXCEEDED_DISK_SPACE,
    USAGE,
    FREE,
    BYTES,
    PERCENTS,
    EXCEEDED_RESOURCE_RAM,
    EXCEEDED_VIRTUAL_RAM,
    EXCEEDED_PROCESSES_COUNT,
    EXCEEDED_THREADS_COUNT,
    EXCEEDED_USAGE_IOWAIT_LOAD,
    EXCEEDED_USAGE_VIRTUAL_RAM,
    EXCEEDED_USAGE_RESOURCE_RAM,
    EXCEEDED_USAGE_DISK_SPACE,
    CLEANUP_BAD_FLAG,
    PID,
    SUBTASK_EXECUTION_ERROR,
    START_CLEANUP_TASK_ERROR,
    EMPTY_FILE_CONTENT,
    GET_CURRENT_TASKS_QUEUE_ERROR,
    GET_LIST_ALL_TASKS_ERROR,
    GET_RESOURCE_USAGE_ERROR,
    TASK_BUSY,
    TARGET_CLIENTS_NOT_AVAILABLE,
    NODE_NOT_SUPPORTED,
    DATA_FILE_IS_EMPTY,
    SET_ENVIRONMENT_ERROR,
    DUMP_RESOURCE_MONITOR_FAIL,
    RESTORE_RESOURCE_MONITOR_FAIL
  };

  const char delimiter = ':';
  const char space = ' ';
  const char point = '.';

  const std::string badJsonFormat = "Bad json format. Not found field: ";
  const std::string badJsonFieldContent = "Bad json format. Bad content of field: ";

  const std::string createDefaultJson = "CREATE DefaultJSON";
  const std::string serializationOutputJsonMessageError = "Serialization error of output json message";
  const std::string emptyCommandLine = "Empty command line";
  const std::string executeCommandFail = "Execute command fail";
  const std::string unknownSessionType = "Unknown session type";
  const std::string objectInstanceWasNotCreated = "Object instance was not created";
  const std::string emptyObjectInstance = "Empty object instance";
  const std::string setHomeDir = "Set HomeDir";
  const std::string error = "Error";
  const std::string errorMsg = "ERROR_MSG";
  const std::string errorCode = "ERROR_CODE";
  const std::string command = "COMMAND";

  const std::string createFileFail = "Create file fail";
  const std::string readFileFail = "Read file fail";
  const std::string deleteFileFail = "Delete file fail";
  const std::string errorReadDataFile = "Error read data file";
  const std::string errorReadRequestFile = "Error read request file";
  const std::string dataFileNotExists = "File of data not exists";
  const std::string requestFileNotExists = "File of request not exists";
  const std::string badFileContent = "Bad file's content";
  const std::string shellScriptNotExist = "Shell script not exist";
  const std::string shellScriptCannotExecute = "Shell script cannot execute";

  const std::string wrongTypeTaskRequest = "Wrong type of task request";
  const std::string wrongTypeThreadMode = "Wrong type of thread mode";
  const std::string executeShellHostCommandFail = "Execute Shell Host command fail";
  const std::string shellHostCommandReturnError = "Shell Host command return error";
  const std::string wrongTypeRemoteExecution = "Wrong type of remote execution";
  const std::string wrongCheckType = "Wrong check type for return status information";
  const std::string wrongFetchType = "Wrong fetch type for get data request";
  const std::string wrongAlgorithmType = "Wrong algorithm type for terminate task request";
  const std::string badCommandParams = "Bad command params";
  const std::string badTaskId = "Bad task ID";
  const std::string dataNotRange = "Task Id not in range";
  const std::string searchTask = "Search task fail";
  const std::string cancelTask = "Cancel task fail";
  const std::string invalidPidProcess = "Invalid pid process";
  const std::string readDataFile = "Read data file fail";
  const std::string errorExecuteNotification = "Error execute notification";

  const std::string taskContinuesToRun = "Task continues to run";
  const std::string taskNotFound = "Task not found";
  const std::string taskDataNotFound = "Task data not found";
  const std::string processWasNotStopped = "Process wasn't stopped";
  const std::string changeState = "Change state";
  const std::string taskTimeExpired = "Task's time expired";
  const std::string taskCanceled = "Task canceled";
  const std::string exceededCpuLoad = "Exceeded max allowed value of CPU load";
  const std::string exceededIOWaitLoad = "Exceeded max allowed value of iowait load";
  const std::string presentLoading = "Present loading is";
  const std::string exceededDiskSpace = "Exceeded min size of disk space";
  const std::string usage = "Usage";
  const std::string free = "Free";
  const std::string bytes = "bytes";
  const std::string percents = "percents";
  const std::string exceededResourceRAM = "Exceeded min size of resource RAM";
  const std::string exceededVirtualRAM = "Exceeded min size of virtual RAM";
  const std::string exceededProcessesCount = "Exceeded max number of processes.";
  const std::string exceededThreadsCount = "Exceeded max number of threads";
  const std::string exceededUsageIOWaitLoad  = "Exceeded max allowed value of iowait load during execution";
  const std::string exceededUsageVirtualRAM = "Exceeded max allowed value of virtual RAM usage during execution";
  const std::string exceededUsageResourceRAM = "Exceeded max allowed value of resource RAM usage during execution";
  const std::string exceededUsageDiskSpace = "Exceeded max allowed value of disk space usage during execution";
  const std::string cleanupBadFlag = "Operation cleanup has bad flag";
  const std::string pid = "PID";
  const std::string subtaskExecutionError = "Subtask execution error";
  const std::string startCleanupTaskError = "Start cleanup task error";
  const std::string emptyFileContent = "Empty file content";
  const std::string getCurrentTasksQueueError = "Get current tasks queue error";
  const std::string getListAllTasksError = "Get list all tasks error";
  const std::string getResourceUsageError = "Get resource usage error";
  const std::string taskBusy = "Task is busy";

  const std::string targetClientsNotAvailable = "No target node clients available";
  const std::string nodeNotSupported = "Node mode not supported";
  const std::string nodeHasNotEnoughResources = "Chosen node has not enough resources for usage";

  const std::string dataFileIsEmpty = "Read empty data file";
  const std::string setEnvironmentError = "Set mandatory environment error";
  const std::string dumpResourceMonitorFail = "Dump of resource monitor failed";
  const std::string restoreResourceMonitorFail = "Restore of resource monitor failed";


  const std::vector<std::pair<unsigned int, std::string> > messages =
  {
      { CREATE_DEFAULT_JSON, createDefaultJson },
      { SERIALIZATION_OUTPUT_JSON_MESSAGE_ERROR, serializationOutputJsonMessageError },
      { EMPTY_COMMAND_LINE,  emptyCommandLine },
      { EXECUTE_COMMAND_FAIL, executeCommandFail },
      { UNKNOWN_SESSION_TYPE, unknownSessionType },
      { OBJECT_INSTANCE_WAS_NOT_CREATED, objectInstanceWasNotCreated },
      { EMPTY_OBJECT_INSTANCE, emptyObjectInstance },
      { SET_HOME_DIR, setHomeDir },
      { ERROR, error },
      { ERROR_MSG, errorMsg },
      { ERROR_CODE, errorCode },
      { COMMAND, command },
      { CREATE_FILE, createFileFail },
      { READ_FILE, readFileFail },
      { DELETE_FILE, deleteFileFail },
      { ERROR_READ_DATA_FILE, errorReadDataFile },
      { ERROR_READ_REQUEST_FILE , errorReadRequestFile },
      { NOT_EXISTS_DATA_FILE, dataFileNotExists },
      { NOT_EXISTS_REQUEST_FILE, requestFileNotExists },
      { ERROR_EXECUTE_NOTIFICATION, errorExecuteNotification },
      { BAD_FILE_CONTENT, badFileContent },
      { SHELL_SCRIPT_NOT_EXIST, shellScriptNotExist },
      { SHELL_SCRIPT_CANNOT_EXECUTE, shellScriptCannotExecute },
      { WRONG_TYPE_TASK_REQUEST, wrongTypeTaskRequest },
      { WRONG_TYPE_THREAD_MODE, wrongTypeThreadMode },
      { EXECUTE_SHELL_HOST_COMMAND_FAIL, executeShellHostCommandFail },
      { SHELL_HOST_COMMAND_RETURN_ERROR, shellHostCommandReturnError },
      { WRONG_TYPE_REMOTE_EXCUTION, wrongTypeRemoteExecution },
      { TASK_CONTINUES_TO_RUN, taskContinuesToRun },
      { WRONG_CHECK_TYPE, wrongCheckType },
      { WRONG_FETCH_TYPE, wrongFetchType },
      { WRONG_ALGORITHM_TYPE, wrongAlgorithmType },
      { BAD_COMMAND_PARAMS, badCommandParams },
      { BAD_TASK_ID, badTaskId },
      { DATA_NOT_RANGE, dataNotRange },
      { SEARCH_TASK, searchTask },
      { CANCEL_TASK, cancelTask },
      { INVALID_PID_PROCESS, invalidPidProcess },
      { TASK_NOT_FOUND, taskNotFound },
      { TASK_DATA_NOT_FOUND, taskDataNotFound },
      { PROCESS_WAS_NOT_STOPPED, processWasNotStopped },
      { CHANGE_STATE, changeState },
      { TASK_TIME_EXPIRED, taskTimeExpired },
      { TASK_CANCELED, taskCanceled },
      { EXCEEDED_CPU_LOAD, exceededCpuLoad },
      { EXCEEDED_IOWAIT_LOAD, exceededIOWaitLoad },
      { PRESENT_LOADING, presentLoading },
      { EXCEEDED_DISK_SPACE, exceededDiskSpace },
      { USAGE, usage },
      { FREE, free },
      { BYTES, bytes },
      { PERCENTS, percents },
      { EXCEEDED_RESOURCE_RAM, exceededResourceRAM },
      { EXCEEDED_VIRTUAL_RAM, exceededVirtualRAM },
      { EXCEEDED_PROCESSES_COUNT, exceededProcessesCount },
      { EXCEEDED_THREADS_COUNT, exceededThreadsCount },
      { EXCEEDED_USAGE_IOWAIT_LOAD, exceededUsageIOWaitLoad },
      { EXCEEDED_USAGE_VIRTUAL_RAM, exceededUsageVirtualRAM },
      { EXCEEDED_USAGE_RESOURCE_RAM, exceededUsageResourceRAM },
      { EXCEEDED_USAGE_DISK_SPACE, exceededUsageDiskSpace },
      { CLEANUP_BAD_FLAG, cleanupBadFlag },
      { PID, pid },
      { SUBTASK_EXECUTION_ERROR, subtaskExecutionError },
      { START_CLEANUP_TASK_ERROR, startCleanupTaskError },
      { EMPTY_FILE_CONTENT, emptyFileContent },
      { GET_CURRENT_TASKS_QUEUE_ERROR, getCurrentTasksQueueError },
      { GET_LIST_ALL_TASKS_ERROR, getListAllTasksError },
      { GET_RESOURCE_USAGE_ERROR, getResourceUsageError },
      { TASK_BUSY , taskBusy },
      { TARGET_CLIENTS_NOT_AVAILABLE, targetClientsNotAvailable },
      { NODE_NOT_SUPPORTED, nodeNotSupported },
      { DATA_FILE_IS_EMPTY, dataFileIsEmpty },
      { SET_ENVIRONMENT_ERROR, setEnvironmentError },
      { DUMP_RESOURCE_MONITOR_FAIL, dumpResourceMonitorFail },
      { RESTORE_RESOURCE_MONITOR_FAIL, restoreResourceMonitorFail }
  };
//-----------------------------------------------------------------------------
} // end namespace message_const
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
namespace drce_const
{
  // constants use in functional object
  const std::string moduleName = "DRCE";  // for init LoggerStream
  const std::string dataFileExt = "data";
  const std::string requestFileExt = "req";
  const std::string dumpFileName = "queue.dump";
  // list names use for resource usage array
  const std::string taskPrefix = "TASK_";
  const std::string hostPrefix = "HOST_";

  const std::string cpu = "CPU";
  const std::string iowait = "IOWAIT";
  const std::string vram = "VRAM";
  const std::string rram = "RRAM";
  const std::string disk = "DISK";
  const std::string processes = "PROCESSES";
  const std::string threads = "THREADS";
  const std::string loadavg = "LOADAVG";

  const std::string taskCpu = taskPrefix+cpu;             // "TASK_CPU"
  const std::string taskVram = taskPrefix+vram;           // "TASK_VRAM"
  const std::string taskRram = taskPrefix+rram;           // "TASK_RRAM"
  const std::string taskThreads = taskPrefix+threads;     // "TASK_THREADS"
  const std::string hostCpu = hostPrefix+cpu;             // "HOST_CPU"
  const std::string hostIowait = hostPrefix+iowait;       // "HOST_IOWAIT"
  const std::string hostVram = hostPrefix+vram;           // "HOST_VRAM"
  const std::string hostRram = hostPrefix+rram;           // "HOST_RRAM"
  const std::string hostDisk = hostPrefix+disk;           // "HOST_DISK"
  const std::string hostProcesses = hostPrefix+processes; // "HOST_PROCESSES"
  const std::string hostThreads = hostPrefix+threads;     // "HOST_THREADS"
  const std::string hostLoadAverage = hostPrefix+loadavg; // "HOST_LOADAVG"
  // constants of logger for tasks queue log
  const std::string DRCE_TASKS_LOGGER = "DRCEFO-Tasks";
  const std::string DRCE_TASKS_LOGGER_DELIMITER = " - ";
  const std::string DRCE_TASKS_LOGGER_CREATED = "C";
  const std::string DRCE_TASKS_LOGGER_DELETED = "D";
  // constants of exit status
  const unsigned int EXIT_STATUS_BASE = 128;
  const unsigned int REPEAT_TRY_READ_DATA_FILE = 5;
} // end namespace drce_const
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce
} // end namespace HCE

#endif // DRCE_MESSAGE_CONST_HPP