SphinxMessageConst.hpp

Go to the documentation of this file.

#ifndef SPHINX_MESSAGE_CONST_HPP
#define SPHINX_MESSAGE_CONST_HPP

namespace HCE
{
namespace sphinx
{
namespace message_const
{
//-----------------------------------------------------------------------------
  enum
  {
    LOAD_CONFIG_SUCCESS=0,
    HOST,
    PORT,
    INDEX,
    FILE_NOT_FOUND,
    FILE_NOT_OPEN,
    SEARCHD_MAX_MATCHES,
    SCHEMA_NAMES_SIZE,
    ATTRIBUTES_COUNT,
    EMPTY_LIST_OF_INDEX_FILES,
    LOAD_CONFIG_FAIL,
    EMPTY_RESULT_DATA,
    INCORRECT_JSON_TYPE,
    ERROR,
    ERROR_MSG,
    ERROR_CODE,
    SERIALIZE_OUTPUT_JSON_MESSAGE,
    GENERATE_DEFAULT_JSON,
    TRY_MAKE_INDEX_COMMAND,
    DOCUMENT_CONTENT_IS_EMPTY,
    INDEX_NAME,
    MAKE_INDEX_COMMAND_SUCCESS,
    TRY_MAKE_ADMIN_COMMAND,
    RECEIVED_EMPTY_COMMAND_STRING,
    UNKNOWN_COMMAND,
    MAKE_ADMIN_COMMAND_SUCCESS,
    FAILED_TO_CREATE_CLIENT,
    START_SEARCHD_READ_CONFIG,
    WAIT_START_SEARCHD,
    START_SEARCHD_FAIL,
    TRY_EASY_START,
    WAIT_STOP_SEARCHD,
    STOP_SEARCHD,
    INVALID_CLIENT_HANDLE,
    INVALID_FILTER,
    ADD_FILTER,
    INVALID_RANGE_OF_FILTER,
    UNKNOWN_FILTER_TYPE,
    SERVER_HOST_IS_EMPTY,
    SERVER_PORT_IS_NULL,
    SET_SERVER_SUCCESS,
    OPEN_CONNECTION_ERROR,
    EASY_START_SUCCESS,
    EASY_START_FALLEN,
    FIELD_ALREADY_EXIST,
    FIELD_NOT_FOUND,
    INDEX_ALREADY_EXIST,
    INDEX_NOT_FOUND,
    INDEX_NOT_EXIST,
    NOT_FOUND_IN_CONFIG,
    LIST_OF_INDEXES_IS_EMPTY,
    SEARCHD_ERROR,
    SEARCHD_WARNING,
    SEARCHD_STOPPED_PID_FILE_EXIST,
    SEARCHD_STOPPED_BUT_PID_FILE_EXIST,
    SEARCHD_NOT_ACTIVITY,
    FIELD_NOT_FOUND_IN_CURRENT_SCHEMA,
    GETTING_PARAMETERS_FAIL,
    ERROR_CLEAN_DIR,
    FOUND_INDEX_FILE,
    REMOVE_INDEX_FILE,
    REMOVE_FILE_FAIL,
    OPEN_DIR_FAIL,
    ERROR_GET_FILE_LIST,
    ERROR_GET_INDEX_LIST,
    EMPTY_DATA_DIR,
    TRY_OPEN_FILE_FAIL,
    TRY_USE_AS_DIRECTORY_WAS_CANCELED,
    CLOSE_DIR_FAIL,
    FOUND_FREE_ALLOWED_PORT,
    ERROR_GET_FREE_ALLOWED_PORT,
    ERROR_MAKE_CONFIG,
    MAKE_DIR_FAIL,
    DONT_CREATED_DIR,
    FOLDER_NOT_EXIST,
    FILE_NOT_EXIST,
    INVALID_DATA_CONTENT,
    INVALID_SCHEMA_CONTENT,
    COMMAND_LINE,
    INDEXATION_FAIL,
    BAD_BRANCH_NAME,
    MAKE_SOURCE_FAIL,
    MAKE_SOURCE,
    MAKE_INDEX,
    RECEIVED_EMPTY_LIST_BRANCHES,
    EMPTY_LIST_OF_FILES_DATA,
    IS_RUN_SEARCHD,
    STOPPED_SEARCHD,
    INDEX_NOT_STARTED,
    SECTION_NAME_NOT_VALID,
    MERGE_BRANCHES_FAIL,
    ERROR_MAKE_MERGE,
    EMPTY_LIST_OF_EXISTING_INDEXES,
    ERROR_MAKE_TRUNK_INDEX,
    RECIEVED_EMPTY_INDEX_NAME,
    RECIEVED_EMPTY_LIST_OF_BRANCHES,
    CALL_REMOVE_INDEX_NAME,
    EMPTY_INDEXES_LIST,
    PREPARE_MERGE,
    IS_MADE_TRUNK,
    IS_ACTIVE_SEARCHD,
    INDEX_FILE_NAME,
    MOVE_FILE_FAIL,
    MAKE_CONFIG_FAIL,
    INDEX_MERGE_FAIL,
    DATA_FILES_ALREADY_DELETED,
    EMPTY_APPEND_DOCUMENT_LIST,
    ERROR_PACK_DATA,
    ERROR_GETTING_DOCUMENT_COUNT,
    EMPTY_BRANCHES_LIST,
    BAD_DOCUMENT_ID,
    REMOVE_DIR_FAIL,
    INDEX_COPY_FAIL,
    GET_STATUS_SEARCHD_FAIL,
    GET_INDEX_STATUS_FAIL,
    SEARCH_MAX_DOCS_ID_FAIL,
    LOAD_SOURCE_FILE_FAIL,
    ERROR_MAKE_BRANCH_CONFIG,
    CURRENT_INDEX_NAME_IS_EMPTY,
    TARGET_CLIENTS_NOT_AVAILABLE,
    NODE_NOT_SUPPORTED,
    SERIALIZATION_OUTPUT_JSON_MESSAGE_ERROR
  };

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

  const std::string loadConfigSuccess =  "LOAD CONFIG SUCCESS";
  const std::string host = "HOST";
  const std::string port = "PORT";
  const std::string index = "INDEX";
  const std::string fileNotFound = "File not found";
  const std::string fileNotOpen = "File not open";
  const std::string searchdMaxMatches = "SEARCHD MAX MATCHES";
  const std::string schemaNamesSize = "SCHEMA NAMES SIZE";
  const std::string attributesCount = "ATTRIBUTES COUNT";
  const std::string emptyListOfindexFiles = "Empty list of index files";
  const std::string loadConfigFail = "LOAD CONFIG FAIL";
  const std::string emptyResultData = "Empty result data";
  const std::string incorrectJSONType = "Incorrect JSON type";
  const std::string errorMessage = "Error";
  const std::string errorMsg = "ErrorMsg";
  const std::string errorCode = "ErrorCode";
  const std::string serializeOutputJsonMessage = "Serialize OutputJsonMessage";
  const std::string generateDefaultJSON = "Generate default JSON";
  const std::string tryMakeIndexCommand =  "TRY MAKE INDEX COMMAND";
  const std::string documentContentIsEmpty = "Document content is empty";
  const std::string indexName = "INDEX NAME";
  const std::string makeIndexCommandSuccess =  "!!! MAKE INDEX COMMAND SUCCESS !!!";
  const std::string tryMakeAdminCommand = "TRY MAKE ADMIN COMMAND";
  const std::string receivedEmptyCommandString = "Received empty command string";
  const std::string unknownCommand = "Unknown command";
  const std::string makeAdminCommandSuccess = "!!! MAKE ADMIN COMMAND SUCCESS !!!";
  const std::string failedToCreateClient = "Failed to create client";
  const std::string startSearchdReadConfig = "startSearchd read config";
  const std::string waitStartSearchd = "!!! WAIT START SEARCHD !!!";
  const std::string startSearchdFail = "Start searchd fail";
  const std::string tryEasyStart = "TRY EASY START";
  const std::string waitStopSearchd = "!!! WAIT STOP SEARCHD !!!";
  const std::string stopSearchd = "STOP SEARCHD";
  const std::string invalidClientHandle = "Invalid client handle";
  const std::string invalidFilter = "Invalid filter";
  const std::string addFilter = "Add filter";
  const std::string invalidRangeOfFilter = "Invalid range of filter";
  const std::string unknownFilterType = "Unknown filter type";
  const std::string serverHostIsEmpty = "Server host is empty";
  const std::string serverPortIsNull = "Server port is null";
  const std::string setServerSuccess = "!!! SET SERVER SUCCESS !!!";
  const std::string openConnectionError = "Open connection error";
  const std::string easyStartSuccess =  "!!! EASY START SUCCESS !!!";
  const std::string easyStartFallen = "!!! EASY START FALLEN !!!";
  const std::string fieldAlreadyExist = "Field already exist";
  const std::string fieldNotFound = "Field not found";
  const std::string indexAlreadyExist = "Index already exist";
  const std::string indexNotFound = "Index not found";
  const std::string indexNotExist = "Index not exist";
  const std::string notFoundInConfig = "NOT FOUND IN CONFIG";
  const std::string listOfIndexesIsEmpty = "List of indexes is empty, check initialization";
  const std::string searchdError = "SEARCHD ERROR";
  const std::string searchdWarning = "SEARCHD WARNING";
  const std::string searchdStoppedPidFileExist = "Searchd stopped. Pid file exist = ";
  const std::string searchdStoppedButPidFileExist = "Searchd stoped but pid file exist";
  const std::string searchdNotActivity = "Searchd not activity";
  const std::string fieldNotFoundInCurrentSchema = "Field not found in current schema";
  const std::string gettingParametersFail = "Getting parameters fail";
  const std::string errorCleanDir = "ERROR CLEAN DIR";
  const std::string foundIndexFile = "FOUND INDEX FILE";
  const std::string removeIndexFile = "REMOVE INDEX FILE";
  const std::string removeFileFail = "Remove file fail";
  const std::string openDirFail = "Open dir fail";
  const std::string errorGetFileList = "ERROR GET FILE LIST";
  const std::string errorGetIndexList = "ERROR GET INDEX LIST";
  const std::string emptyDataDir = "Empty data dir";
  const std::string tryOpenFileFail = "Try open file fail";
  const std::string tryUseAsDirectoryWasCanceled = "Try use as directory was canceled...";
  const std::string closeDirFail = "Close dir fail";
  const std::string foundFreeAllowedPort = "FOUND FREE ALLOWED PORT";
  const std::string errorGetFreeAllowedPort = "ERROR GET FREE ALLOWED PORT";
  const std::string errorMakeConfig = "ERROR MAKE CONFIG";
  const std::string makeDirFail = "Make dir fail";
  const std::string dontCreatedDir = "Don't created directory";
  const std::string folderNotExist = "Forder not exist";
  const std::string fileNotExist = "File not exist";
  const std::string invalidDataContent = "Invalid data content";
  const std::string invalidSchemaContent = "Invalid schema content";
  const std::string commandLine = "COMMAND LINE";
  const std::string indexationFail = "Indexation fail";
  const std::string badBranchName = "Bad branch name";
  const std::string makeSourceFail = "Make source fail";
  const std::string makeSource = "MAKE SOURCE";
  const std::string makeIndex = "MAKE INDEX";
  const std::string receivedEmptyListOfBranches = "Received empty list of branches";
  const std::string emptyListOfFilesData = "Empty list of files data";
  const std::string isRunSearchd = "isRunSearchd => ";
  const std::string stoppedSearchd = "STOPPED SEARCHD => ";
  const std::string indexNotStarted = "Index not started";
  const std::string sectionNameNotValid = "Section name not valid";
  const std::string mergeBranchesFail = "Merge branches fail";
  const std::string errorMakeMerge = "ERROR MAKE MERGE";
  const std::string emptyListOfExistingIndexes = "Empty list of existing indexes";
  const std::string errorMakeTrunkIndex = "ERROR MAKE TRUNK INDEX";
  const std::string receivedEmptyIndexName = "Received empty index name";
  const std::string callRemoveIndexFile = "Call removeIndexFile";
  const std::string emptyIndexesList = "Empty indexes list";
  const std::string prepareMerge = "Prepare merge. Make";
  const std::string isMadeTrunk = "isMadeTrunk => ";
  const std::string isActiveSearchd = "IS ACTIVE SEARCHD => ";
  const std::string indexFileName = "Index file name";
  const std::string moveFileFail = "Move file fail";
  const std::string makeConfigFail = "Make config fail";
  const std::string indexMergeFail = "Index merge fail";
  const std::string dataFilesAlreadyDeleted = "Data files already deleted";
  const std::string emptyAppendDocumentList = "Empty append document list";
  const std::string errorPackData = "ERROR PACK DATA";
  const std::string errorGettingDocumentCount = "ERROR GETTING DOCUMENT COUNT";
  const std::string emptyBranchesList = "Empty branches list";
  const std::string badDocumentId = "Bad document ID";
  const std::string removeDirFail = "Remove dir fail";
  const std::string indexCopyFail = "Index copy fail";
  const std::string getStatusSearchdFail = "Get status searchd fail";
  const std::string getIndexStatusFail = "Get index status fail";
  const std::string searchMsxDocsIDFail = "Search MaxDocsID fail";
  const std::string loadSourceFileFail = "Load source file fail";
  const std::string errorMakeBranchConfig = "ERROR MAKE BRANCH CONFIG";
  const std::string currentIndexNameIsEmpty = "Current index name is empty";
  const std::string attribute = "Attribute";
  const std::string haveInvalidArgument = "have invalid argument";
  const std::string badXmlSource = "Bad xml source";
  const std::string valueIsEmpty = "value is empty";
  const std::string cannotBeConvertToUnsignedLongLong = "cannot be convert to unsigned long long";
  const std::string haveEmptyAttributeList = "have empty attribute list";

  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 serializationOutputJsonMessageError = "Serialization error of output json message";

  const std::vector<std::pair<unsigned int, std::string> > messages =
  {
      { LOAD_CONFIG_SUCCESS, loadConfigSuccess },
      { HOST, host },
      { PORT, port },
      { INDEX, index },
      { FILE_NOT_FOUND, fileNotFound },
      { FILE_NOT_OPEN, fileNotOpen },
      { SEARCHD_MAX_MATCHES, searchdMaxMatches },
      { SCHEMA_NAMES_SIZE, schemaNamesSize },
      { ATTRIBUTES_COUNT, attributesCount },
      { EMPTY_LIST_OF_INDEX_FILES, emptyListOfindexFiles },
      { LOAD_CONFIG_FAIL, loadConfigFail },
      { EMPTY_RESULT_DATA, emptyResultData },
      { INCORRECT_JSON_TYPE, incorrectJSONType },
      { ERROR, errorMessage },
      { ERROR_MSG, errorMsg },
      { ERROR_CODE, errorCode },
      { SERIALIZE_OUTPUT_JSON_MESSAGE, serializeOutputJsonMessage },
      { GENERATE_DEFAULT_JSON, generateDefaultJSON },
      { TRY_MAKE_INDEX_COMMAND, tryMakeIndexCommand },
      { DOCUMENT_CONTENT_IS_EMPTY, documentContentIsEmpty },
      { INDEX_NAME, indexName },
      { MAKE_INDEX_COMMAND_SUCCESS, makeIndexCommandSuccess },
      { TRY_MAKE_ADMIN_COMMAND, tryMakeAdminCommand },
      { RECEIVED_EMPTY_COMMAND_STRING, receivedEmptyCommandString },
      { UNKNOWN_COMMAND, unknownCommand },
      { MAKE_ADMIN_COMMAND_SUCCESS, makeAdminCommandSuccess },
      { FAILED_TO_CREATE_CLIENT, failedToCreateClient },
      { START_SEARCHD_READ_CONFIG, startSearchdReadConfig },
      { WAIT_START_SEARCHD, waitStartSearchd },
      { START_SEARCHD_FAIL, startSearchdFail },
      { TRY_EASY_START, tryEasyStart },
      { WAIT_STOP_SEARCHD, waitStopSearchd },
      { STOP_SEARCHD, stopSearchd },
      { INVALID_CLIENT_HANDLE, invalidClientHandle },
      { INVALID_FILTER, invalidFilter },
      { ADD_FILTER, addFilter },
      { INVALID_RANGE_OF_FILTER, invalidRangeOfFilter },
      { UNKNOWN_FILTER_TYPE, unknownFilterType },
      { SERVER_HOST_IS_EMPTY, serverHostIsEmpty },
      { SERVER_PORT_IS_NULL, serverPortIsNull },
      { SET_SERVER_SUCCESS, setServerSuccess },
      { OPEN_CONNECTION_ERROR, openConnectionError },
      { EASY_START_SUCCESS, easyStartSuccess },
      { EASY_START_FALLEN, easyStartFallen },
      { FIELD_ALREADY_EXIST, fieldAlreadyExist },
      { FIELD_NOT_FOUND, fieldNotFound },
      { INDEX_ALREADY_EXIST, indexAlreadyExist },
      { INDEX_NOT_FOUND, indexNotFound },
      { INDEX_NOT_EXIST, indexNotExist },
      { NOT_FOUND_IN_CONFIG, notFoundInConfig },
      { LIST_OF_INDEXES_IS_EMPTY, listOfIndexesIsEmpty },
      { SEARCHD_ERROR, searchdError },
      { SEARCHD_WARNING, searchdWarning },
      { SEARCHD_STOPPED_PID_FILE_EXIST, searchdStoppedPidFileExist },
      { SEARCHD_STOPPED_BUT_PID_FILE_EXIST, searchdStoppedButPidFileExist },
      { SEARCHD_NOT_ACTIVITY, searchdNotActivity },
      { FIELD_NOT_FOUND_IN_CURRENT_SCHEMA, fieldNotFoundInCurrentSchema },
      { GETTING_PARAMETERS_FAIL, gettingParametersFail },
      { ERROR_CLEAN_DIR, errorCleanDir },
      { FOUND_INDEX_FILE, foundIndexFile },
      { REMOVE_INDEX_FILE, removeIndexFile },
      { REMOVE_FILE_FAIL, removeFileFail },
      { OPEN_DIR_FAIL, openDirFail },
      { ERROR_GET_FILE_LIST, errorGetFileList },
      { ERROR_GET_INDEX_LIST, errorGetIndexList },
      { EMPTY_DATA_DIR, emptyDataDir },
      { TRY_OPEN_FILE_FAIL, tryOpenFileFail },
      { TRY_USE_AS_DIRECTORY_WAS_CANCELED, tryUseAsDirectoryWasCanceled },
      { CLOSE_DIR_FAIL, closeDirFail },
      { FOUND_FREE_ALLOWED_PORT, foundFreeAllowedPort },
      { ERROR_GET_FREE_ALLOWED_PORT, errorGetFreeAllowedPort },
      { ERROR_MAKE_CONFIG, errorMakeConfig },
      { MAKE_DIR_FAIL, makeDirFail },
      { DONT_CREATED_DIR, dontCreatedDir },
      { FOLDER_NOT_EXIST, folderNotExist },
      { FILE_NOT_EXIST, fileNotExist },
      { INVALID_DATA_CONTENT, invalidDataContent },
      { INVALID_SCHEMA_CONTENT, invalidSchemaContent },
      { COMMAND_LINE, commandLine },
      { INDEXATION_FAIL, indexationFail },
      { BAD_BRANCH_NAME, badBranchName },
      { MAKE_SOURCE_FAIL, makeSourceFail },
      { MAKE_SOURCE, makeSource },
      { MAKE_INDEX, makeIndex },
      { RECEIVED_EMPTY_LIST_BRANCHES, receivedEmptyListOfBranches },
      { EMPTY_LIST_OF_FILES_DATA, emptyListOfFilesData },
      { IS_RUN_SEARCHD, isRunSearchd },
      { STOPPED_SEARCHD, stoppedSearchd },
      { INDEX_NOT_STARTED, indexNotStarted },
      { SECTION_NAME_NOT_VALID, sectionNameNotValid },
      { MERGE_BRANCHES_FAIL, mergeBranchesFail },
      { ERROR_MAKE_MERGE, errorMakeMerge },
      { EMPTY_LIST_OF_EXISTING_INDEXES, emptyListOfExistingIndexes },
      { ERROR_MAKE_TRUNK_INDEX, errorMakeTrunkIndex },
      { RECIEVED_EMPTY_INDEX_NAME, receivedEmptyIndexName },
      { RECIEVED_EMPTY_LIST_OF_BRANCHES, receivedEmptyListOfBranches },
      { CALL_REMOVE_INDEX_NAME, callRemoveIndexFile },
      { EMPTY_INDEXES_LIST, emptyIndexesList },
      { PREPARE_MERGE, prepareMerge },
      { IS_MADE_TRUNK, isMadeTrunk },
      { IS_ACTIVE_SEARCHD, isActiveSearchd },
      { INDEX_FILE_NAME, indexFileName },
      { MOVE_FILE_FAIL, moveFileFail },
      { MAKE_CONFIG_FAIL, makeConfigFail },
      { INDEX_MERGE_FAIL, indexMergeFail },
      { DATA_FILES_ALREADY_DELETED, dataFilesAlreadyDeleted },
      { EMPTY_APPEND_DOCUMENT_LIST, emptyAppendDocumentList },
      { ERROR_PACK_DATA, errorPackData },
      { ERROR_GETTING_DOCUMENT_COUNT, errorGettingDocumentCount },
      { EMPTY_BRANCHES_LIST, emptyBranchesList },
      { BAD_DOCUMENT_ID, badDocumentId },
      { REMOVE_DIR_FAIL , removeDirFail },
      { INDEX_COPY_FAIL, indexCopyFail },
      { GET_STATUS_SEARCHD_FAIL, getStatusSearchdFail },
      { GET_INDEX_STATUS_FAIL, getIndexStatusFail },
      { SEARCH_MAX_DOCS_ID_FAIL, searchMsxDocsIDFail },
      { LOAD_SOURCE_FILE_FAIL, loadSourceFileFail },
      { ERROR_MAKE_BRANCH_CONFIG, errorMakeBranchConfig },
      { CURRENT_INDEX_NAME_IS_EMPTY, currentIndexNameIsEmpty },
      { TARGET_CLIENTS_NOT_AVAILABLE, targetClientsNotAvailable },
      { NODE_NOT_SUPPORTED, nodeNotSupported },
      { SERIALIZATION_OUTPUT_JSON_MESSAGE_ERROR, serializationOutputJsonMessageError }
  };
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace message_const
} // namespace sphinx
} // namespace HCE

#endif // SPHINX_MESSAGE_CONST_HPP