hce-node/html/_d_r_c_e_message_const_8hpp_source.html

#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