SphinxIndexer.cpp

Go to the documentation of this file.

#include <sstream>
#include <fstream>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <Poco/AutoPtr.h>

#include "EncodeDecodeBase64.hpp"
#include "SphinxIndexer.hpp"
#include "SphinxInputJsonMessageIndex.hpp"
#include "SphinxInputJsonMessageManage.hpp"
#include "SphinxInputJsonMessage.hpp"
#include "SphinxOutputJsonMessage.hpp"
#include "SphinxAdminCommand.hpp"
#include "SphinxDataSource.hpp"
#include "SphinxError.hpp"
#include "SphinxConfigCreator.hpp"
#include "ProcExec.hpp"
#include "SphinxMessageConst.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxIndexer::SphinxIndexer(SphinxFunctionalObject& fObj_)
: inherited(), fObj(fObj_), message(fObj.getCustomMessage())
{
}
//-----------------------------------------------------------------------------
std::string SphinxIndexer::Process(const std::string& json)
{
  _isError = false;
  errorMsg.clear();
  errorCode = NO_ERROR;
  std::string resultData;
  timeval tvStart, tvStop;
  gettimeofday(&tvStart, 0); //gettimeofday does not support TZ adjust on Linux.

  try
  {
    SphinxInputJsonMessage inputMessage(json);
    if (inputMessage.isError())
      throw Poco::Exception(inputMessage.getErrorMsg(), PARSE_ERROR);

    if (inputMessage.getType() == SphinxInputJsonMessage::MessageType::mtIndex)
    {
      makeIndexCommand(inputMessage.getData());
    }
    else if (inputMessage.getType() == SphinxInputJsonMessage::MessageType::mtManage)
    {
      makeAdminCommand(inputMessage.getData(), resultData);
    }
    else
      throw Poco::Exception(message(message_const::INCORRECT_JSON_TYPE), COMMAND_ERROR);

  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorCode = e.code();
    errorMsg = e.displayText();
    fObj.log() << message(message_const::ERROR, errorMsg) << std::endl;
  }

  std::string resJson;
  gettimeofday(&tvStop, 0);

  SphinxOutputJsonMessage outputMessage;
  outputMessage.setErrorCode(errorCode);
  outputMessage.setErrorMessage(errorMsg);
  outputMessage.setData(resultData);
  outputMessage.setTime(getTimeInterval(tvStart, tvStop)/1000);
  bool success = outputMessage.serialize(resJson);
  if (!_isError)
    _isError = !success;

  return resJson;
}
//-----------------------------------------------------------------------------
void SphinxIndexer::makeIndexCommand(const std::string& json) throw (Poco::Exception)
{
  _isError = false;
  errorMsg.clear();
  errorCode = NO_ERROR;

  fObj.log() << message(message_const::TRY_MAKE_INDEX_COMMAND) << std::endl;
  SphinxInputJsonMessageIndex messageIndex(json);
  if (messageIndex.isError())
    throw Poco::Exception(messageIndex.getErrorMsg(), COMMAND_ERROR);

  if (messageIndex.getDocumentFile().empty())
    throw Poco::Exception(message(message_const::DOCUMENT_CONTENT_IS_EMPTY), COMMAND_ERROR);

  const std::string targetIndexName = (messageIndex.getIndexName().empty())?fObj.getIndexName():messageIndex.getIndexName();
  SphinxFunctionalObject fObject(fObj.getNodeName(), fObj.getHomeDir(), targetIndexName,
      sphinx_search_const::searchdNotStart,
      sphinx_search_const::searchdNotStop);

  fObj.log() << message(message_const::INDEX_NAME, targetIndexName) << std::endl;
  fObject.setLogStream(fObj.log());

  IndexCheck indexCheck(fObject);
  indexCheck.setIndexName(targetIndexName);
  if (!indexCheck.execute())
    throw Poco::Exception(indexCheck.getErrorMsg(), ERROR_INDEXATION_REQUEST);

  IndexAppendDataFile indexAppendDataFile(fObject);
  indexAppendDataFile.setIndexName(targetIndexName);
  indexAppendDataFile.setBranchName(sphinx_search_const::defaultBranchName);
  indexAppendDataFile.setDataContent(messageIndex.getDocumentFile());
  if (!indexAppendDataFile.execute())
    throw Poco::Exception(indexAppendDataFile.getErrorMsg(), ERROR_INDEXATION_REQUEST);

  IndexPackDocData indexPackDocData(fObject);
  indexPackDocData.setIndexName(targetIndexName);
  indexPackDocData.addBranch(sphinx_search_const::defaultBranchName);
  if (!indexPackDocData.execute())
    throw Poco::Exception(indexPackDocData.getErrorMsg(), ERROR_INDEXATION_REQUEST);

  IndexRebuild indexRebuild(fObject);
  indexRebuild.setIndexName(targetIndexName);
  indexRebuild.addBranch("*");
  if (!indexRebuild.execute())
    throw Poco::Exception(indexRebuild.getErrorMsg(), ERROR_INDEXATION_REQUEST);

  IndexMerge indexMerge(fObject);
  indexMerge.setIndexName(targetIndexName);
  indexMerge.addBranch("*");
  if (!indexMerge.execute())
    throw Poco::Exception(indexMerge.getErrorMsg(), ERROR_INDEXATION_REQUEST);

  fObj.log() << message(message_const::MAKE_INDEX_COMMAND_SUCCESS) << std::endl;
}
//-----------------------------------------------------------------------------
void SphinxIndexer::makeAdminCommand(const std::string& json, std::string& resultData) throw (Poco::Exception)
{
  _isError = false;
  errorMsg.clear();
  errorCode = NO_ERROR;

  fObj.log() << message(message_const::TRY_MAKE_ADMIN_COMMAND) << std::endl;
  SphinxInputJsonMessageManage messageManage(json);
  if (messageManage.isError())
    throw Poco::Exception(messageManage.getErrorMsg(), COMMAND_ERROR);

  if (messageManage.getCommandString().empty())
    throw Poco::Exception(message(message_const::RECEIVED_EMPTY_COMMAND_STRING), COMMAND_ERROR);

  SphinxAdminCommandFactory commandFactory;
  Poco::SharedPtr<SphinxAdminCommand> pCmd = commandFactory.create(fObj, messageManage.getCommandString());
  if (pCmd.isNull())
    throw Poco::Exception(message(message_const::UNKNOWN_COMMAND, messageManage.getCommandString()), COMMAND_ERROR);

  std::string localJson = messageManage.getCommandOptionsString();
  if (!pCmd->unserialize(localJson))
    throw Poco::Exception(pCmd->getErrorMsg(), pCmd->getErrorCode());

  bool res = pCmd->execute();
  resultData = pCmd->getResultData();
  if (!res)
    throw Poco::Exception(pCmd->getErrorMsg(), pCmd->getErrorCode());

  fObj.log() << message(message_const::MAKE_ADMIN_COMMAND_SUCCESS) << std::endl;
}
//-----------------------------------------------------------------------------
SphinxOutputJsonMessage SphinxIndexer::Process(SphinxInputJsonMessage& inputJsonMessage)
{
  _isError = false;
  errorMsg.clear();
  errorCode = NO_ERROR;
  std::string resultData;
  timeval tvStart, tvStop;
  gettimeofday(&tvStart, 0);          //gettimeofday does not support TZ adjust on Linux.

  try
  {
    if (inputJsonMessage.getType() == SphinxInputJsonMessage::MessageType::mtIndex)
    {
      makeIndexCommand(inputJsonMessage.getData());
    }
    else if (inputJsonMessage.getType() == SphinxInputJsonMessage::MessageType::mtManage)
    {
      makeAdminCommand(inputJsonMessage.getData(), resultData);
    }
    else
      throw Poco::Exception(message(message_const::INCORRECT_JSON_TYPE), COMMAND_ERROR);
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorCode = e.code();
    errorMsg = e.displayText();
    fObj.log() << message(message_const::ERROR, errorMsg) << std::endl;
  }

  gettimeofday(&tvStop, 0);

  SphinxOutputJsonMessage outputMessage;
  outputMessage.setErrorCode(errorCode);
  outputMessage.setErrorMessage(errorMsg);
  outputMessage.setData(resultData);
  outputMessage.setTime(getTimeInterval(tvStart, tvStop)/1000);

  return outputMessage;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace sphinx
} // end namespace HCE