hce-node/html/_handler_types_8hpp_source.html

#ifndef __HCE_HANDLER_TYPES_INCLUDED__

#define __HCE_HANDLER_TYPES_INCLUDED__


#include "zmsg.hpp"

#include "ClientWorkerItem.hpp"


namespace HCE {

  namespace handlers {

    const unsigned int HEARTBEAT_DELAY = 15000;

    const unsigned int HEARTBEAT_TIMEOUT = 60000;

    const unsigned int LOG_STATISTIC_PERIOD = 30000;

    const unsigned int RECONNECT_INTERVAL_INIT = 10000;

    const unsigned int RECONNECR_INTERVAL_MAX = 30000;

    const unsigned int POLL_TIMEOUT = HEARTBEAT_DELAY/2;

    const unsigned int STAT_INTERVAL = 60000;

    const unsigned int PROPERTY_INTERVAL = 10000;

    const unsigned int DUMP_INTERVAL = 3600*1000;


    const unsigned int MIN_ALLOWED_HEARTBEAT_DELAY = 5000;

    const unsigned int MIN_ALLOWED_HEARTBEAT_TIMEOUT = 5000;

    const unsigned int MIN_ALLOWED_POLL_TIMEOUT = 5000;

    const unsigned int MIN_ALLOWED_PROPERTY_INTERVAL = 5000;

    const unsigned int MIN_ALLOWED_DUMP_INTERVAL = 5000;


    const unsigned int HEARBEAT_MODE_FIXED_TIME = 0;

    const unsigned int HEARBEAT_MODE_IMMEDIATE_AFTER_HB = 1;

    const unsigned int HEARBEAT_MODE_MIXED = 2;

    const unsigned int HEARBEAT_MODE_ADAPTIVE = 3;


    const unsigned int HEARBEAT_MODE_DEFAULT = HEARBEAT_MODE_FIXED_TIME;

    const unsigned int HEARBEAT_MODE_MAX_NUMBER = HEARBEAT_MODE_ADAPTIVE;


    const unsigned char NODE_MODE_PROXY = 0;

    const unsigned char NODE_MODE_SHARD = 1;

    const unsigned char NODE_MODE_DATA = 2;

    const unsigned char NODE_MODE_ROUTER = 3;

    const unsigned char NODE_MODE_SHARD_RND = 4;

    const unsigned char NODE_MODE_SHARD_RU = 5;


    const unsigned int NODE_MSG_DATA_MIN_FIELDS = 2;

    const unsigned int NODE_MSG_CMD_MIN_FIELDS = 1;


    const unsigned int NODE_LOG_MODE_NONE        = 0;

    const unsigned int NODE_LOG_MODE_FATAL       = 1;

    const unsigned int NODE_LOG_MODE_CRITICAL    = 2;

    const unsigned int NODE_LOG_MODE_ERROR       = 3;

    const unsigned int NODE_LOG_MODE_WARNING     = 4;

    const unsigned int NODE_LOG_MODE_NOTICE      = 5;

    const unsigned int NODE_LOG_MODE_INFORMATION = 6;

    const unsigned int NODE_LOG_MODE_DEBUG       = 7;

    const unsigned int NODE_LOG_MODE_TRACE       = 8;


    const unsigned int NODE_LOG_MODE_DEFAULT = NODE_LOG_MODE_INFORMATION;


    const unsigned int NODE_EXIT_CODE_GENERAL_CRITICAL_ERROR = 1;

    const unsigned int NODE_EXIT_CODE_SPHINX_CRITICAL_ERROR = 2;

    const unsigned int NODE_EXIT_CODE_DRCE_CRITICAL_ERROR = 3;


    const unsigned int NODE_CONNECTION_REBUILD_DELAY_DEFAULT = 60000;  //Connection rebuild delay, ms

    const unsigned int NODE_CONNECTION_REBUILD_MAX_TRIES = 100;        //Connection rebuild max tries number


    const char NODE_ROUTER_MSG_DELIMITER = '@';

    const char NODE_ADMIN_COMMAND_DELIMITER = 0x09;

    const char NODE_JSON_BEGIN_CHAR = '{';

    const std::string NODE_JSON_EMPTY_DEFAULT = "{}";

    const char NODE_ADMIN_COMMAND_PROPERTY_ITEMS_DELIMITER = ',';

    const char NODE_ADMIN_COMMAND_PROPERTY_ITEM_PAIR_DELIMITER = ':';

    const char ROUTE_TABLE_MSG_TITLE_DELIMITER = ':';

    const char ROUTE_LIST_NAMES_DELIMITER = ',';

    const char ROUTE_LIST_COUNT_DELIMITER = ':';

    const char HEARTBEAT_MSG_DELIMITER = ':';

    const char PROPERTY_MSG_DELIMITER = ':';

    const std::string HEARTBEAT_JSON_RESOURCES = "resources";

    const std::string HEARTBEAT_JSON_ROUTES = "routes";


    //Ini file params values related

    const char NODE_INI_FILE_PATH_START_CHAR = '/';

    const char NODE_INI_FILE_PATH_DELIMITER_CHAR = '/';


    const unsigned int NODE_DATA_PROCESSING_MODE_NORMAL = 0;

    const unsigned int NODE_DATA_PROCESSING_MODE_SIMULATE = 1;


    const std::string ZMQ_PROTOCOL_PREFIX_TCP = "tcp://";

    const std::string ZMQ_PROTOCOL_PREFIX_INPROC = "inproc://";


    const std::string NODE_CS_INPROC_ADMIN = ZMQ_PROTOCOL_PREFIX_INPROC + "inproc_admin";

    const std::string NODE_CS_INPROC_PROXY = ZMQ_PROTOCOL_PREFIX_INPROC + "inproc_proxy";

    const std::string NODE_CS_INPROC_DATA = ZMQ_PROTOCOL_PREFIX_INPROC + "inproc_data";

    const std::string NODE_CS_INPROC_REDUCER_OUT = ZMQ_PROTOCOL_PREFIX_INPROC + "inproc_reducer_out";

    const std::string NODE_CS_INPROC_REDUCER_IN = ZMQ_PROTOCOL_PREFIX_INPROC + "inproc_reducer_in";


    const std::string NODE_MSG_READY = "READY";

    const std::string NODE_MSG_HEARTBEAT = "HEARTBEAT";

    const std::string NODE_MSG_BYE = "BYE";


    const std::string NODE_MSG_ECHO = "ECHO";

    const std::string NODE_MSG_LOG_LEVEL_SET = "LLSET";

    const std::string NODE_MSG_LOG_LEVEL_GET = "LLGET";

    const std::string NODE_MSG_HEARTBEAT_DELAY_SET = "HEARTBEAT_DELAY_SET";

    const std::string NODE_MSG_HEARTBEAT_DELAY_GET = "HEARTBEAT_DELAY_GET";

    const std::string NODE_MSG_HEARTBEAT_TIMEOUT_SET = "HEARTBEAT_TIMEOUT_SET";

    const std::string NODE_MSG_HEARTBEAT_TIMEOUT_GET = "HEARTBEAT_TIMEOUT_GET";

    const std::string NODE_MSG_HEARTBEAT_MODE_SET = "HEARTBEAT_MODE_SET";

    const std::string NODE_MSG_HEARTBEAT_MODE_GET = "HEARTBEAT_MODE_GET";

    const std::string NODE_MSG_POLL_TIMEOUT_SET = "POLL_TIMEOUT_SET";

    const std::string NODE_MSG_POLL_TIMEOUT_GET = "POLL_TIMEOUT_GET";

    const std::string NODE_MSG_PROPERTY_INTERVAL_SET = "PROPERTY_INTERVAL_SET";

    const std::string NODE_MSG_PROPERTY_INTERVAL_GET = "PROPERTY_INTERVAL_GET";

    const std::string NODE_MSG_DUMP_INTERVAL_SET = "DUMP_INTERVAL_SET";

    const std::string NODE_MSG_DUMP_INTERVAL_GET = "DUMP_INTERVAL_GET";


    const std::string NODE_MSG_STAT = "STAT";

    const std::string NODE_MSG_TIME = "TIME";

    const std::string NODE_MSG_PROPERTIES = "PROPERTIES";

    const std::string NODE_MSG_rebuildServerConnection = "rebuildServerConnection";

    const std::string NODE_MSG_REBUILD_CLIENT_CONNECTION = "REBUILD_CLIENT_CONNECTION";

    const std::string NODE_MSG_UPDATE_SCHEMA = "UPDATE_SCHEMA";

    const std::string NODE_MSG_DISCONNECT_SERVER_CONNECTION = "DISCONNECT_SERVER_CONNECTION";

    const std::string NODE_MSG_DISCONNECT_CLIENT_CONNECTION = "DISCONNECT_CLIENT_CONNECTION";

    const std::string NODE_MSG_SHUTDOWN = "SHUTDOWN";

    const std::string NODE_MSG_SPHINX = "SPHINX";

    const std::string NODE_MSG_DRCE = "DRCE";

    const std::string NODE_MSG_DRCE_SET_HOST = "DRCE_SET_HOST";

    const std::string NODE_MSG_DRCE_GET_HOST = "DRCE_GET_HOST";

    const std::string NODE_MSG_DRCE_SET_PORT = "DRCE_SET_PORT";

    const std::string NODE_MSG_DRCE_GET_PORT = "DRCE_GET_PORT";

    const std::string NODE_MSG_DRCE_GET_TASKS = "DRCE_GET_TASKS"; // for return async task queue

    const std::string NODE_MSG_DRCE_GET_TASKS_INFO = "DRCE_GET_TASKS_INFO"; // for return async tasks information


    const std::string NODE_MSG_ROUTES = "NODE_ROUTES"; // for return routes of cluster nodes

    const std::string NODE_MSG_RESOURCE_USAGE = "NODE_RESOURCE_USAGE"; // for return resource usage array

    const std::string NODE_MSG_SET_DATA_PROCESSING_MODE = "SET_DATA_PROCESSING_MODE";

    const std::string NODE_MSG_GET_DATA_PROCESSING_MODE = "GET_DATA_PROCESSING_MODE";

    const std::string NODE_MSG_MANAGER_MODE_SET = "MMSET";

    const std::string NODE_MSG_MANAGER_MODE_GET = "MMGET";

    const std::string NODE_MSG_MANAGER_PURGE_MODE_SET = "MPMSET";

    const std::string NODE_MSG_MANAGER_PURGE_MODE_GET = "MPMGET";

    const std::string NODE_MSG_MANAGER_RESOURCES_COLLECTED_SIZE_SET = "MRCSSET";

    const std::string NODE_MSG_MANAGER_RESOURCES_COLLECTED_SIZE_GET = "MRCSGET";

    const std::string NODE_MSG_STOP = "STOP"; //Supported by all handlers except of "Admin"


    const std::string NODE_ADMIN_ERROR_WRONG_FORMAT = "Wrong admin message format, expected string - DESTINATION_IDENTITY:COMMAND_NAME:PARAMETERS, or destination admin handler not found";

    const std::string NODE_ADMIN_ERROR_UNSUPPORTED_COMMAND = "REDEFINED admin command handler - unsupported admin command!";

    const std::string NODE_ADMIN_ERROR_HANDLER_NOT_FOUND = "Handler not found or not connected to inproc admin server";

    const std::string NODE_ADMIN_ERROR_UNSUPPORTED_CC_REBUILD = "Client connection rebuild not supported for handler ";

    const std::string NODE_ADMIN_ERROR_OK = "OK";

    const std::string NODE_ADMIN_ERROR_ERROR = "ERROR";

    const std::string NODE_ADMIN_ERROR_MAIN_MSG_LOOP_STARTED = "Main messages loop started";

    const std::string NODE_ADMIN_ERROR_MAIN_MSG_LOOP_STOPPED = "Main messages loop stopped";


    const std::string NODE_ADMIN_HANDLER = "Admin";


    const std::string NODE_FUNCTIONAL_ERROR_SPHINX = "SPHINX_FO_ERR";

    const std::string NODE_FUNCTIONAL_ERROR_SPHINX_ADMIN = "SPHINX_FO_ADMIN_ERR";

    const std::string NODE_FUNCTIONAL_ERROR_SPHINX_ADMIN_JSON_MSG = "{\"error_code\":\"1\", \"error_message\": \"Sphinx FO error\", \"data\":\"ERROR\", \"time\":\"-1\"}";

    const std::string NODE_FUNCTIONAL_ERROR_SPHINX_INTERNAL_LOG_BEGIN = "\n!!!SPHINXFO!!![\n";

    const std::string NODE_FUNCTIONAL_ERROR_SPHINX_INTERNAL_LOG_END = "\n]!!!SPHINXFO!!!\n";

    const std::string NODE_CRITICAL_ERROR_MESSAGE = "Critical error, can't continue, execution aborted!";

    const std::string NODE_FUNCTIONAL_ERROR_SPHINX_REDUCER = "SPHINX_REDUCER_FO_ERR";


    const std::string NODE_FUNCTIONAL_PROJECT_ROOT_DIR = "hce-node-bundle";

    const bool NODE_FUNCTIONAL_SPHINX_NOT_START_SEARCHD = false;

    const bool NODE_FUNCTIONAL_SPHINX_NOT_STOP_SEARCHD = false;

    const unsigned int NODE_FUNCTIONAL_SPHINX_RANKER_0 = 0;

    const std::string NODE_FUNCTIONAL_DRCE_TASKS_DATA_DIR = "data";

    const std::string NODE_FUNCTIONAL_DRCE_TASKS_STATUS_DIR = "log";


    const std::string NODE_FUNCTIONAL_ERROR_DRCE = "DRCE_FO_ERR";

    const std::string NODE_FUNCTIONAL_ERROR_DRCE_INTERNAL_LOG_BEGIN = "\n!!!DRCEFO!!![\n";

    const std::string NODE_FUNCTIONAL_ERROR_DRCE_INTERNAL_LOG_END = "\n]!!!DRCEFO!!!\n";


    const std::string NODE_ADMIN_PROPERTY_NAME_LOG = "log";

    const std::string NODE_ADMIN_PROPERTY_NAME_MMODE = "mode";

    const std::string NODE_ADMIN_PROPERTY_HEARTBEAT_DELAY = "hb_delay";

    const std::string NODE_ADMIN_PROPERTY_HEARTBEAT_TIMEOUT = "hb_timeout";

    const std::string NODE_ADMIN_PROPERTY_HEARTBEAT_MODE = "hb_mode";

    const std::string NODE_ADMIN_PROPERTY_POLL_TIMEOUT = "poll_timeout";

    const std::string NODE_ADMIN_PROPERTY_PROPERTY_INTERVAL = "property_interval";

    const std::string NODE_ADMIN_PROPERTY_DUMP_INTERVAL = "dump_interval";

    const std::string NODE_ADMIN_PROPERTY_RESOURCES_COLLECTED_SIZE = "collected_size";


    const size_t DRCE_RESOURCES_EXTRACTOR_MAX_THREADS = 1024;

    const size_t DRCE_RESOURCES_EXTRACTOR_MAX_PROCESSES = 1024;

    const size_t DRCE_RESOURCES_EXTRACTOR_MAX_DISK_SIZE = 0;

    const size_t DRCE_RESOURCES_EXTRACTOR_MAX_VRAM_SIZE = 0;

    const size_t DRCE_RESOURCES_EXTRACTOR_MAX_RRAM_SIZE = 0;

    const unsigned int RESOURCES_USAGE_COLLECTED_SIZE = 10;

    const double RESOURCES_USAGE_MAX_ALLOWED_RANGE = 10.0;


    const std::string NODE_LOG_DEAFULT_TIME_FORMAT = "[%Y-%m-%d %H:%M:%s] ";

    const int NODE_LOG_DEAFULT_MASK = 8+4+2+1;


    const int DRCE_REQUEST_STATE_ERROR_SET_AS_NEW_TASK = 6;


    const unsigned int PROPERTY_REALTIME_DEFAULT = 1;


    const unsigned int DUMP_ALLOWED_RESTORE = 1;


    const std::string DUMP_DIR = "/tmp/hce-node";


    typedef struct {

        std::string bodies;

        size_t count;

    } DefaultReducerResponseItem;


    namespace properties {

      const std::string NAME = "name";

      const std::string CLIENT_IDENTITY = "clientIdentity";

      const std::string STARTED_AT = "startedAt";

      const std::string LOG_PRIORITY = "logPriority";

      const std::string INI_FILE = "iniFile";

      const std::string CONNECTION_REBUILD_TRIES_MAX = "connectionRebuildTriesMax";

      const std::string CONNECTION_REBUILD_TRIES_DELAY = "connectionRebuildTriesDelay";

      const std::string CONNECTION_STRING = "connectionString";

      const std::string POLL_TIMEOUT = "pollTimeout";

      const std::string PROPERTY_INTERVAL = "node.property_interval";

      const std::string DUMP_INTERVAL = "node.dump_interval";

      const std::string DUMP_ALLOW_RESTORE = "node.dump_allow_restore";

      const std::string DUMP_DIR = "node.dump_dir";

      const std::string STAT_REQUESTS_TOTAL = "statRequestsTotal";

      const std::string STAT_REQUESTS = "statRequests";

      const std::string STAT_RESPONSES = "statResponses";

      const std::string STAT_REQUESTS_SIZE = "statRequestsSize";

      const std::string STAT_RESPONSES_SIZE = "statResponsesSize";

      const std::string STAT_REQUESTS_PROCESSED = "statRequestsProcessed";

      const std::string STAT_RESPONSES_PROCESSED = "statResponsesProcessed";

      const std::string STAT_REQUESTS_PROCESSED_SIZE = "statRequestsProcessedSize";

      const std::string STAT_RESPONSES_PROCESSED_SIZE = "statResponsesProcessedSize";

      const std::string STAT_QPS = "statQPS";

      const std::string STAT_RPS = "statRPS";

      const std::string STAT_REQUESTS_BANDWIDTH = "statRequestsBandwidth";

      const std::string STAT_RESPONSES_BANDWIDTH = "statResponsesBandwidth";

      const std::string PSTATS_AT = "pstatsAt";

      const std::string CLIENTS_NUMBER = "clientsNumber";

      const std::string NODE_MODE = "nodeMode";

      const std::string RESOURCES_USAGE_ALG = "node.resources_usage_alg";

      const std::string RESOURCES_USAGE_ALG0_WEIGHTS = "node.resources_usage_alg0_weights";

      const std::string RESOURCES_USAGE_USAGE_ORDER = "node.resources_usage_order";

      const std::string RESOURCES_USAGE_LIMITS = "node.resources_usage_limits";

      const std::string RESOURCES_USAGE_COLLECTED_SIZE = "node.resources_usage_collected_size";

      const std::string RESOURCES_USAGE_MAX_ALLOWED_RANGE = "node.resources_usage_max_allowed_range";

      const std::string DRCE_RESOURCES_EXTRACTOR_MAX_THREADS = "drce.drce_resources_extractor_max_threads";

      const std::string DRCE_RESOURCES_EXTRACTOR_MAX_PROCESSES = "drce.drce_resources_extractor_max_processes";

      const std::string DRCE_RESOURCES_EXTRACTOR_MAX_DISK_SIZE = "drce.drce_resources_extractor_max_disk_size";

      const std::string DRCE_RESOURCES_EXTRACTOR_MAX_VRAM_SIZE = "drce.drce_resources_extractor_max_vram_size";

      const std::string DRCE_RESOURCES_EXTRACTOR_MAX_RRAM_SIZE = "drce.drce_resources_extractor_max_rram_size";

      const std::string STAT_CLIENT_REQUESTS = "statClientRequests";

      const std::string STAT_CLIENT_RESPONSES = "statClientResponses";

      const std::string STAT_CLIENT_REQUESTS_SIZE = "statClientRequestsSize";

      const std::string STAT_CLIENT_RESPONSES_SIZE = "statClientResponsesSize";

      const std::string PEREODIC_STAT_CLIENT_REQUESTS = "periodicStatClientRequests";

      const std::string PEREODIC_STAT_CLIENT_RESPONSES = "periodicStatClientResponses";

      const std::string PEREODIC_STAT_CLIENT_REQUESTS_SIZE = "periodicStatClientRequestsSize";

      const std::string PEREODIC_STAT_CLIENT_RESPONSES_SIZE = "periodicStatClientResponsesSize";

      const std::string STAT_QPS_CLIENT = "statQPSClient";

      const std::string STAT_QPS_SERVER = "statQPSServer";

      const std::string STAT_RPS_CLIENT = "statRPSClient";

      const std::string STAT_RPS_SERVER = "statRPSServer";

      const std::string STAT_REQUESTS_BANDWIDTH_CLIENT = "statRequestsBandwidthClient";

      const std::string STAT_REQUESTS_BANDWIDTH_SERVER = "statRequestsBandwidthServer";

      const std::string STAT_RESPONSES_BANDWIDTH_CLIENT = "statResponsesBandwidthClient";

      const std::string STAT_RESPONSES_BANDWIDTH_SERVER = "statResponsesBandwidthServer";

      const std::string HEARTBEAT_DELAY = "node.hb_delay";

      const std::string HEARTBEAT_TIMEOUT = "node.hb_timeout";

      const std::string HEARTBEAT_MODE = "node.hb_mode";

      const std::string HEARTBEAT_AT = "heartbeatAt";

      const std::string HEARTBEATED_AT = "heartbeatedAt";

      const std::string DATA_CLIENT_SOCK_MODE = "dataClientSockMode";

      const std::string NODE_NAME = "nodeName";

      const std::string NODE_NUMBER = "node.number";

      const std::string DATA_PROCESSING_MODE = "node.data_processing_mode";

      const std::string DATA_PROCESSING_FAKE_RESULTS = "node.data_processing_fake_results";

      const std::string DATA_PROCESSING_FAKE_RESULTS_MAX = "node.data_processing_fake_max_results";


      const std::string STAT_SPHINX_REQUESTS_SEARCH = "statSphinxRequestsSearch";

      const std::string STAT_SPHINX_REQUESTS_ADMIN = "statSphinxRequestsAdmin";

      const std::string STAT_SPHINX_TIME_TOTAL_SEARCH = "statSphinxTimeTotalSearch";

      const std::string STAT_SPHINX_TIME_TOTAL_ADMIN = "statSphinxTimeTotalAdmin";

      const std::string STAT_DRCE_REQUESTS = "statDRCERequests";

      const std::string STAT_DRCE_TIME_TOTAL = "statDRCETimeTotal";


      const std::string SPHINX_HOME_DIR = "sphinx.home_dir";

      const std::string SPHINX_DEFAULT_INDEX = "sphinx.default_index";

      const std::string SPHINX_START_SEARCHD = "sphinx.start_searchd";

      const std::string SPHINX_STOP_SEARCHD = "sphinx.stop_searchd";

      const std::string SPHINX_RANKER = "sphinx.ranker";

      const std::string SPHINX_RANKER_EXPRESSION = "sphinx.ranker_expression";


      const std::string SPHINX_INDEX_NAME = "sphinx.indexName";

      const std::string SPHINX_SEARCHD_HOST = "sphinx.searchdHost";

      const std::string SPHINX_SEARCHD_PORT = "sphinx.searchdPort";

      const std::string SPHINX_TIMEOUTED_REQUESTS = "sphinx.timeoutedRequests";

      const std::string SPHINX_NODE_NUMBER = "sphinx.nodeNumber";

      const std::string SPHINX_NODE_NAME = "sphinx.nodeName";


      const std::string DRCE_HOME_DIR = "drce.home_dir";

      const std::string DRCE_TASKS_DATA_DIR = "drce.tasks_data_dir";

      const std::string DRCE_TASKS_STATUS_DIR = "drce.tasks_status_dir";

      const std::string DRCE_NODE_HOST = "drce.node_host";

      const std::string DRCE_NODE_PORT = "drce.node_port";

      const std::string DRCE_MAX_THREADS = "drce.max_threads";

      const std::string DRCE_TASKS_QUEUE_DUMP_PERIOD = "drce.tasks_queue_dump_period";

      const std::string DRCE_RESOURCES_MONITOR_PERIOD = "drce.resources_monitor_period";

      const std::string DRCE_STATE_NOTIFICATION_HOST = "drce.state_notification_host";

      const std::string DRCE_STATE_NOTIFICATION_PORT = "drce.state_notification_port";

      const std::string DRCE_STATE_NOTIFICATION_RESET_ERROR_CODE = "drce.state_notification_reset_error_code";

      const std::string DRCE_ENV_VARS = "drce.env_vars";


      const std::string DRCE_NODE_NAME = "drce.nodeName";

      const std::string DRCE_TASK_DATA_DIR = "tasksDataDir";

      const std::string DRCE_TASK_STATUS_DIR = "tasksStatusDir";

      const std::string DRCE_MAX_THREAD_COUNT = "maxThreadCount";

      const std::string DRCE_TASK_QUEUE_DUMP_PERIOD = "tasksQueueDumpPeriod";

      const std::string DRCE_RESOURCE_MONITOR_TIME_PERIOD = "resourceMonitorTimePeriod";


    }

  }


  const std::string DRCE_FAKE_RESPONSE =

  "[{"

  " \"error_code\": 1,"

  "  \"error_message\": \"!!!FAKE JSON!!!\","

  "  \"id\": 12345,"

  "  \"type\": 1,"

  "  \"host\": \"\","

  "  \"port\": 0,"

  "  \"state\": 0,"

  "  \"pid\": 0,"

  "  \"stdout\": \"\","

  "  \"stderror\": \"\","

  "  \"exit_status\": \"\","

  "  \"files\": [],"

  "  \"node\": \"FAKE NODE\","

  "  \"time\": 0"

  "}]";

}


#endif /* __HCE_HANDLER_TYPES_INCLUDED__ */