Application.cpp

Go to the documentation of this file.

#include <msgpack.hpp>
#include <Poco/Timestamp.h>
#include <Poco/Exception.h>
#include <sstream>

#include "Application.hpp"
#include "ContentsStorageSimple.hpp"
#include "CRC64.h"
#include "ErrorStruct.hpp"
#include "InDataHighlight.hpp"
#include "HighlightingAlgorithmInitialize.hpp"
#include "HighlightStringStickerSimple.hpp"
#include "HighlightComponent.hpp"
#include "HighlightJsonException.hpp"
#include "HighlightJsonWrapper.hpp"
#include "Logger.hpp"
#include "SerializeCacheData.hpp"

#define COMPONENTS_COUNT 4

using namespace HCE;
using namespace HCE::component;
using namespace HCE::exception;

namespace HCE 
{
  extern Poco::AutoPtr<Poco::Util::AbstractConfiguration> _config;
}

ErrorStruct errorStruct;

Application::Application():exitFlag(false), componentManagerPool(nullptr), crossThreadBufPtr(nullptr), contentsStoragePtr(nullptr)
{
}

Application::~Application() throw()
{
}

void Application::factoriesRegister()
{
  componentsFactory.registerClass<HighlightComponent>(HCE::CT_HIGHLIGHT);
}

void Application::componentsInitialize()
{
  Poco::SharedPtr<Poco::ThreadPool> thPool = Poco::SharedPtr<Poco::ThreadPool>(new Poco::ThreadPool());
  Poco::SharedPtr<ComponentBase> localComponent = nullptr;
  Poco::SharedPtr<ComponentManager> localComponentManager = nullptr;
  componentManagerPool = Poco::SharedPtr<ComponentManagerPoolIf>(new ComponentManagerPool());

  localComponentManager = Poco::SharedPtr<ComponentManager>(new ComponentManager());
  localComponentManager->setThreadPool(thPool);
  
  for(unsigned int i = 0; i < COMPONENTS_COUNT; i++)
  {
    localComponent = componentsFactory.createInstance(HCE::CT_HIGHLIGHT);
    HighlightStringGenerator &highlightStringGenerator = (localComponent.cast<HighlightComponent>())->getHighlightStringGeneratorReference();
    highlightStringGenerator.setHighlightStringSticker(new HighlightStringStickerSimple());
    HCE::HighlightingAlgorithmsInit(highlightStringGenerator);
    localComponentManager->addComponent(localComponent);    
  }
  componentManagerPool->addManager(HCE::CT_HIGHLIGHT, localComponentManager, true);
  localComponentManager->start();
}

void Application::addWCache(unsigned long long &resCrc, std::string &wCacheBase64)
{
  std::string wcacheString = HCE::decodeBase64(wCacheBase64);
  if(wcacheString.length() > 0)
  {
    SerializeCacheData serializeCacheData;
    msgpack::unpacked msg;
    msgpack::unpack(&msg, wcacheString.c_str(), wcacheString.length());
    msgpack::object obj = msg.get();
    try
    {
      obj.convert<SerializeCacheData>(&serializeCacheData);
      if(serializeCacheData.resCrc != resCrc)
      {
        std::cerr << ">>> Bad Resource cache CRC "<< std::endl;
      }
      else
      {
        ContentsStorageBase::WordPosPtrType wordPosPtr = ContentsStorageBase::WordPosPtrType(new std::vector<std::map<unsigned long long, std::vector<WordPos> > >());
        (*wordPosPtr) = serializeCacheData.data;
        (contentsStoragePtr.cast<ContentsStorageSimple>())->cacheAddElement(resCrc, wordPosPtr);        
      }
    }
    catch(msgpack::type_error &err)
    {
      std::cerr << ">>> Bad MSGPACK format "<< std::endl;
    }
  }
}

void Application::extractWCache(msgpack::sbuffer &msgPackBuf, Poco::SharedPtr<OutDataStruct> outDataStructPtr)
{
  std::string inBuff(msgPackBuf.data(), msgPackBuf.size());
  std::string base64Buff = ((msgPackBuf.size() > 0 ) ? HCE::encodeBase64(inBuff) : "");
  outDataStructPtr->addWcache(base64Buff);
}

void Application::highlightComponentExecutor(Poco::SharedPtr<InDataStruct> inDataStructPtr, Poco::SharedPtr<OutDataStruct> outDataStructPtr)
{
  Poco::SharedPtr<DataBase> outData = nullptr;
  Poco::SharedPtr<InDataHighlight> inDataHighlight = nullptr;
  CRC64 crc64;
// a) ------------------------------------------------------------------
  crossThreadBufPtr = Poco::SharedPtr<CrossThreadBuf>(new CrossThreadBuf());
  crossThreadBufPtr->setIsSendWordsMapBack(inDataStructPtr->getSendCacheBack());
  for(unsigned int y = 0; y < inDataStructPtr->getContentsCount(); y++)
  {
    unsigned long long resCrc = 0llu;
    CrossThreadBuf::ResElement inOutDataElem;
    resCrc = crc64.calc(inDataStructPtr->getContent(y).c_str(), inDataStructPtr->getContent(y).length());
    if(contentsStoragePtr.cast<ContentsStorageSimple>())
    {
      if(inDataStructPtr->getWcachesCount() > y)
      {
        addWCache(resCrc, inDataStructPtr->getWcache(y));
      }
    }
    inOutDataElem.setInData(inDataStructPtr->getContent(y));
    inOutDataElem.setOutData("");
    inOutDataElem.setId(y);
    inOutDataElem.setResCrc(resCrc);
    crossThreadBufPtr->addInOutData(inOutDataElem);
  }
  unsigned int timeout = HCE::_config->getInt(HIGHLIGHT_TIMEOUT_MLS_NAME);
  if(inDataStructPtr->getParamsCount() > 0 && inDataStructPtr->getParams(0).timeout != 0)
  {
    timeout = inDataStructPtr->getParams(0).timeout;
  }
  crossThreadBufPtr->setTimeout(timeout);
// b) ------------------------------------------------------------------
  for(unsigned int y = 0; y < inDataStructPtr->getContentsCount(); y++)
  {
    inDataHighlight = Poco::SharedPtr<InDataHighlight>(new InDataHighlight(CT_HIGHLIGHT));
    inDataHighlight->setInDataStructPtr(inDataStructPtr);
    inDataHighlight->setContentsStorageBasePtr(contentsStoragePtr);
    inDataHighlight->setCrossThreadBufPtr(crossThreadBufPtr);
    try
    {
      componentManagerPool->addInData(inDataHighlight);
    }
    catch(ComponentExceptionBase &excp)
    {
    }
  }
// c) ------------------------------------------------------------------

// cppcheck-suppress variableScope
  unsigned int tOut = 0;
  while(true)
  {
    tOut = crossThreadBufPtr->getRestTimeout();
    if(tOut > 0)
    {
      if(crossThreadBufPtr->isTaskFinished())
      {
        break;
      }
      crossThreadBufPtr->waitCv(tOut);
    }
    else
    {
      break;
    }
  }

  try
  {
    componentManagerPool->clearTaskQueue(CT_HIGHLIGHT);
  }
  catch(ComponentExceptionBase &excp)
  {
  }
// d) ------------------------------------------------------------------
  unsigned int highlightCounterSum = 0;
  crossThreadBufPtr->lock();
  if(!crossThreadBufPtr->isTaskFinished())
  {
    errorStruct.addErrorCode(ERROR_FLAG_WAS_TIMEOUT);
  }
  for(unsigned int y = 0; y < crossThreadBufPtr->elemsCount(); y++)
  {
    CrossThreadBuf::ResElement &elem = crossThreadBufPtr->getElem(y);
    std::string &outputStr = elem.getOutData();
    outDataStructPtr->addContent(outputStr);
    highlightCounterSum += elem.getHighlightCounter();
    if(elem.getMsgPackBuff().size() > 0)
    {
      extractWCache(elem.getMsgPackBuff(), outDataStructPtr);
    }
    else
    {
      outDataStructPtr->addWcache("");
    }
  }
  outDataStructPtr->setFoundCounter(highlightCounterSum);
  outDataStructPtr->setHighlightedCounter(highlightCounterSum);  
  crossThreadBufPtr->unlock();
  crossThreadBufPtr = nullptr;
}

int Application::main(const std::vector<std::string>& args)
{
  int ret = Poco::Util::Application::EXIT_OK;
// a) ------------------------------------------------------------------   
  if(checkNeededConfigParams())
  {
    factoriesRegister();
    componentsInitialize();
    contentsStoragePtr = Poco::SharedPtr<ContentsStorageBase>(new ContentsStorageSimple(HCE::_config->getInt(REFINES_COUNT_NAME)));
    HighlightJsonWrapper highlightJsonWrapper;
    Poco::Timestamp timer;
    while(!exitFlag)
    {
      timer.update();
      std::string incomeString;
      Poco::SharedPtr<InDataStruct> inDataStructPtr = nullptr;
      Poco::SharedPtr<OutDataStruct> outDataStructPtr = Poco::SharedPtr<OutDataStruct>(new OutDataStruct());
      outDataString = "";
// b) ------------------------------------------------------------------    
      readData(incomeString);
      if(!incomeString.empty())
      {
        try
        {
          inDataStructPtr = highlightJsonWrapper.inDataFromJsomString(incomeString);
        }
        catch(HighlightJsonException &excpt)
        {
          std::cerr << ">>> Error with parsing incoming JSON = ["<< excpt.what() << "]" << std::endl;
        }
        if(!inDataStructPtr.isNull() && inDataStructPtr->getParamsCount() > 0)
        {
          timer.update();
// c) ------------------------------------------------------------------
          highlightComponentExecutor(inDataStructPtr, outDataStructPtr);
        }
      }
      outDataStructPtr->setErrorCode(errorStruct.getErrorCode());
      outDataStructPtr->setErrorMsg(errorStruct.resolveErrorString());
      outDataStructPtr->setHighlightedCounter(outDataStructPtr->getHighlightedCounter());
      outDataStructPtr->setFoundCounter(outDataStructPtr->getFoundCounter());
      try
      {
// d) -----------------------------------------------------------------
        highlightJsonWrapper.jsonStringFromOutData(outDataStructPtr, outDataString, timer.elapsed());
      }
      catch(HighlightJsonException &excpt)
      {
        std::cerr << ">>> Error with creating outgoing JSON String = "<< std::endl;
      }
      std::cout << outDataString << std::endl;
      break;
    }
  }
  else
  {
    ret = Poco::Util::Application::EXIT_CONFIG;
  }
  return ret;
}

void Application::readData(std::string &incomeString)
{
  std::stringbuf sBuff;
  std::cin.get(sBuff, BREAK_SYMBOL);
  incomeString = sBuff.str();  
}

bool Application::checkNeededConfigParams()
{
  bool ret = true;
  try
  {
    HCE::_config->getInt(HIGHLIGHT_TIMEOUT_MLS_NAME);
    HCE::_config->getInt(REFINES_COUNT_NAME);
  }
  catch(const Poco::NotFoundException& exception)
  {
    Poco::Message msg("Application",exception.displayText() + ServerApplication::ADDITION_INFORM_STRING_NOT_FOUND, Poco::Message::PRIO_CRITICAL,__FILE__,__LINE__);
    HCE::Logger::writeLog(msg);
    ret = false;
  }
  return ret;
}

// cppcheck-suppress unusedFunction
void Application::handleHelp(const std::string& name,const std::string& value)
{
  this->_showHelpInfo = true;
  Poco::Util::HelpFormatter helpFormatter(options());
  helpFormatter.setCommand(commandName());
  helpFormatter.setUsage("OPTIONS");
  helpFormatter.setHeader("Some options that demonstrates some of the features of the Highlighter application");
  helpFormatter.format(std::cout);
  ::_exit(Poco::Util::Application::EXIT_OK);  
}

// cppcheck-suppress unusedFunction
void Application::handleVersion(const std::string& name,const std::string& value)
{
  std::string appVersion = std::string(APP_VERSION) + " " + std::string(__DATE__) + " " + std::string(__TIME__);
  std::cout << appVersion << std::endl;
  ::_exit(Poco::Util::Application::EXIT_OK);  
}