SphinxAdminCommand.cpp

Go to the documentation of this file.

#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>

#include <Poco/JSON/Object.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/JSON.h>
#include <Poco/JSON/Stringifier.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/JSONException.h>
#include <Poco/Dynamic/Var.h>
#include <Poco/URI.h>
#include <Poco/String.h>

#include "EncodeDecodeBase64.hpp"
#include "SphinxAdminCommand.hpp"
#include "SphinxDataSource.hpp"
#include "SphinxDataFile.hpp"
#include "SphinxSchemaFile.hpp"
#include "SphinxError.hpp"
#include "ProcExec.hpp"
#include "SphinxConfigCreator.hpp"
#include "XMLCleaner.hpp"
#include "SphinxDataSourceParameters.hpp"
#include "SphinxConfigOptions.hpp"
#include "SphinxMessageConst.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxAdminCommand::SphinxAdminCommand(SphinxFunctionalObject& fObj_)
: inherited(), fObj(fObj_), resultData(""), message(fObj.getCustomMessage())
{
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::makeDir(const std::string& path)
{
  bool result = false;
  mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO;
  struct stat st;

  if (stat(path.c_str(), &st) != 0)
  {
    if (mkdir(path.c_str(), mode) != 0)
      errorMsg = strerror(errno);
    else
      result = true;
  }
  else if (!S_ISDIR(st.st_mode))
  {
    errorMsg = strerror(ENOTDIR);
  }

  if (!result)
    errorCode = ERROR_MAKE_DIR;

  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::cleanDir(const std::string& path)
{
  bool result = false;
  if (isExistDir(path))
  {
    struct dirent* ent = nullptr;
    DIR* dir = opendir (path.c_str());
    if (dir != nullptr)
    {
      result = true;
      std::string fileName;
      while ((ent = readdir (dir)) != nullptr)
      {
        fileName = ent->d_name;
        if (fileName != "." && fileName != "..")
        {
          fileName = path+"/"+ent->d_name;

          if (remove(fileName.c_str())==-1)
            result = false;
        }
      }
      if (closedir(dir)==-1)
        result = false;
    }
  }
  if (!result)
  {
    errorCode = ERROR_CLEAN_DIR;
    errorMsg = strerror(errno);
    fObj.log() << message(message_const::ERROR_CLEAN_DIR, errorMsg) << std::endl;
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::isExistDir(const std::string& path)
{
  bool result = false;
  DIR* dir = nullptr;

  dir = opendir (path.c_str());
  if (dir != nullptr)
  {
    if (closedir(dir)==-1)
      errorMsg = strerror(errno);
    else
      result = true;
  }
  else
  {
    if (errno!=ENOENT)
      errorMsg = strerror(errno);
  }

  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::isExistFile(const std::string& file)
{
  return (access(file.c_str(), F_OK)==0);
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::isAllowedString(const std::string& str)
{
  return (str.find_first_not_of(sphinx_admin_command_const::allowedSimbols)==std::string::npos);
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::copyFile(const std::string& srcFile, const std::string& dstFile)
{
  bool result = false;
  try
  {
    if (!isExistFile(srcFile))
      throw Poco::Exception(srcFile+" not exists", ERROR_COPY_FILE);

    std::string cmd("cp");
    std::vector<std::string> args = {srcFile, dstFile};

    std::stringstream outMsg;
    ProcExec procExec(cmd, args);
    if (!procExec.exec(outMsg, outMsg))
      throw Poco::Exception("Copy '"+srcFile+"' to '"+dstFile+"' fail", ERROR_COPY_FILE);

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str(), ERROR_COPY_FILE);

    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::moveFile(const std::string& srcFile, const std::string& dstFile)
{
  bool result = false;
  try
  {
    if (!isExistFile(srcFile))
      throw Poco::Exception(srcFile+" not exists", ERROR_MOVE_FILE);

    std::string cmd("mv");
    std::vector<std::string> args = {srcFile, dstFile};

    std::stringstream outMsg;
    ProcExec procExec(cmd, args);
    if (!procExec.exec(outMsg, outMsg))
      throw Poco::Exception("Move '"+srcFile+"' to '"+dstFile+"' fail", ERROR_MOVE_FILE);

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str(), ERROR_MOVE_FILE);

    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::removeFile(const std::string& file)
{
  bool result = false;
  if (remove(file.c_str())==0)
    result = true;
  else
  {
    errorMsg = strerror(errno);
    errorCode = ERROR_REMOVE_FILE;
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::moveIndexFiles(const std::string& indexFileName, const std::string& srcPath, const std::string& dstPath)
{
  errorMsg.clear();
  bool result = false;

  struct dirent *d;
  DIR* dir = opendir(srcPath.c_str());
  if (dir != NULL)
  {
    result = true;
    std::string oldName, newName;
    while((d = readdir(dir)))
    {
      oldName = d->d_name;
      if (oldName.find(indexFileName) != std::string::npos)
      {
        oldName = srcPath + "/" + d->d_name;
        newName = dstPath + "/" + d->d_name;
        if (!moveFile(oldName, newName))
        {
          result = false;
          break;
        }
      }
    }
    if (closedir(dir)==-1)
    {
      errorMsg.append(" ").append(strerror(errno));
      result = false;
    }
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::copyIndexFiles(const std::string& indexFileName, const std::string& srcPath, const std::string& dstPath)
{
  errorMsg.clear();
  bool result = false;

  struct dirent *d;
  DIR* dir = opendir(srcPath.c_str());
  if (dir != NULL)
  {
    result = true;
    std::string oldName, newName;
    while((d = readdir(dir)))
    {
      oldName = d->d_name;
      if (oldName.find(indexFileName) != std::string::npos)
      {
        oldName = srcPath + "/" + d->d_name;
        newName = dstPath + "/" + d->d_name;
        if (!copyFile(oldName, newName))
        {
          result = false;
          break;
        }
      }
    }
    if (closedir(dir)==-1)
    {
      errorMsg.append(" ").append(strerror(errno));
      result = false;
    }
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::removeIndexFile(const std::string& indexFileName, const std::string& path)
{
  errorMsg.clear();
  bool result = false;

  struct dirent *d;
  DIR* dir = opendir(path.c_str());
  if (dir != NULL)
  {
    result = true;
    std::string fileName;
    std::vector<std::string> files;
    while((d = readdir(dir)))
    {
      fileName = d->d_name;
      if (fileName.compare(0, indexFileName.length(), indexFileName)==0)
      {
        if (!(d->d_name == std::string(".") || d->d_name == std::string("..")))
        {
          fileName = path + "/" + d->d_name;
          files.push_back(fileName);
        }
        fObj.log() << message(message_const::FOUND_INDEX_FILE, fileName) << std::endl;
      }
    }
    if (closedir(dir)==-1)
    {
      errorMsg.append(" ").append(strerror(errno));
      result = false;
    }
    // remove all found index files
    for (size_t i=0;i<files.size();++i)
    {
      fObj.log() << message(message_const::REMOVE_INDEX_FILE, files[i]) << std::endl;
      if (remove(files[i].c_str())!=0)
      {
        result = false;
        errorMsg = message(message_const::REMOVE_FILE_FAIL, files[i])+message(message_const::ERROR, strerror(errno));
      }
    }
  }
  else
    errorMsg = message(message_const::OPEN_DIR_FAIL, path)+message(message_const::ERROR, strerror(errno));

  if (!errorMsg.empty())
    fObj.log() << message(message_const::REMOVE_INDEX_FILE, errorMsg) << std::endl;

  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::getFileList(const std::string& path, std::vector<std::string>& vFiles, const std::string& ext)
{
  bool result = false;
  DIR* dir = nullptr;

  std::string findExtension = "."+ext;
  dir = opendir (path.c_str());
  if (dir != nullptr)
  {
    struct dirent* ent = nullptr;
    while ((ent = readdir (dir)) != nullptr)
    {
      std::string sourceFileName(ent->d_name);
      size_t found = sourceFileName.find(findExtension);
      if (found !=std::string::npos)
      {
        sourceFileName = sourceFileName.substr(0, found);
        vFiles.push_back(sourceFileName);
      }
    }
    if (closedir(dir)==-1)
      errorMsg = strerror(errno);
    else
      result = true;
  }
  else
    errorMsg = strerror(errno);

  if (!result)
  {
    errorCode = ERROR_GET_FILE_LIST;
    fObj.log() << message(message_const::ERROR_GET_FILE_LIST, errorMsg) << std::endl;
  }

  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::getIndexList(const std::string& path, std::vector<std::string>& vIndexes)
{
  vIndexes.clear();
  bool result = false;
  DIR* dir = nullptr;
  struct dirent* ent = nullptr;

  dir = opendir (path.c_str());
  if (dir != nullptr)
  {
    std::set<std::string> sIndexes;
    std::string fileName;
    while ((ent = readdir (dir)) != nullptr)
    {
      if (!(ent->d_name == std::string(".") || ent->d_name == std::string("..")))
      {
        fileName = ent->d_name;
        size_t found = fileName.find_last_of('.');
        if (found!=std::string::npos)
        {
          sIndexes.insert(fileName.substr(0, found));
        }
      }
    }
    if (closedir(dir)==-1)
      errorMsg = strerror(errno);
    else
    {
      vIndexes.assign(sIndexes.begin(), sIndexes.end());
      result = true;
    }
   }
  else
    errorMsg = strerror(errno);

  if (!result)
  {
    errorCode = ERROR_GET_INDEX_LIST;
    fObj.log() <<  message(message_const::ERROR_GET_INDEX_LIST, errorMsg) << std::endl;
  }

  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::getFreeAllowedPort(unsigned int& res)
{
  bool result = false;

  try
  {
    if (fObj.getDataDir().empty())
      throw Poco::Exception(message(message_const::EMPTY_DATA_DIR));

    std::set<unsigned int> ports;
    DIR* dir = nullptr;
    struct dirent* ent = nullptr;

    dir = opendir (fObj.getDataDir().c_str());
    if (dir == nullptr)
      throw Poco::Exception(message(message_const::OPEN_DIR_FAIL, fObj.getDataDir())+message(message_const::ERROR, strerror(errno)));

    Poco::AutoPtr<SphinxConfigCreator> pConf = nullptr;
    while ((ent = readdir (dir)) != nullptr)
    {
      std::string name = ent->d_name;
      if (!(name=="."||name==".."))
      {
        if (isExistDir(fObj.getDataDir()+"/"+name))
        {
          const std::string propFile = fObj.getDataDir()+"/"+ent->d_name+"/"+sphinx_search_const::sphinxPropertyFile;

          try
          {
            pConf = new SphinxConfigCreator(propFile);

            std::string host;
            unsigned int port;
            fObj.parseHostPort(pConf->getString(sphinx_search_const::searchdListen), host, port);
            ports.insert(port);
          }
          catch(std::exception& exc)
          {
            fObj.log() << message(message_const::TRY_OPEN_FILE_FAIL, propFile) << message(message_const::ERROR, exc.what()) << std::endl;
          }
        }
        else
          fObj.log() << message(message_const::TRY_USE_AS_DIRECTORY_WAS_CANCELED) << "'" << fObj.getDataDir() << "/" << name << "'" << std::endl;
      }
    }

    if (closedir(dir)==-1)
      throw Poco::Exception(message(message_const::CLOSE_DIR_FAIL)+message(message_const::ERROR, strerror(errno)));

    for (unsigned int i=sphinx_search_const::defaultPort;i<sphinx_search_const::maxAllowedPort;++i)
    {
      std::set<unsigned int>::iterator iter = ports.find(i);
      if (iter==ports.end())
      {
        res = i;
        break;
      }
    }
    fObj.log() << message(message_const::FOUND_FREE_ALLOWED_PORT, res) << std::endl;
    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_GET_FREE_ALLOWED_PORT;
    fObj.log() << message(message_const::ERROR_GET_FREE_ALLOWED_PORT, errorMsg) << std::endl;
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::makeTrunkConfig(const std::string& trunkName, const std::string& indexName, const std::string& indexFileName,
    SphinxConfigOptions& configOptions)
{
  bool result = false;
  const std::string path = fObj.getDataDir()+"/"+indexName;
  const std::string propFile = path+"/"+sphinx_search_const::sphinxPropertyFile;
  const std::string sphinxConfigFile = path+"/"+sphinx_search_const::sphinxConfigName;
  try
  {
    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);

    // saved for possibility restore
    configOptions.setCreatedDate(pConf->getUInt64(sphinx_admin_command_const::optionsCreatedDate, 0));
    pConf->remove(sphinx_admin_command_const::sectionOptions);  // remove need to sphinx indexer

    std::vector<std::string> keys;
    pConf->keys(keys);

    for (size_t i=0;i<keys.size();++i)
    {
      if (keys[i].find(sphinx_search_const::sourceNameField)!=std::string::npos)
      {
        std::string name = keys[i]+"."+sphinx_search_const::xmlpipeCommandNameField;
        std::string value = "cat "+path+"/"+sphinx_admin_command_const::dataDir+"/"+indexFileName+"."+sphinx_admin_command_const::sourceFileExtension;
        pConf->setString(name, value);
      }
    }
    std::string name = sphinx_search_const::indexNameField+" "+trunkName+"."+sphinx_search_const::pathNameField;
    std::string value = path+"/"+trunkName;
    pConf->setString(name, value);

    value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdLogFile;
    pConf->setString(sphinx_search_const::searchdLogName, value);

    value = fObj.getRunDir()+"/"+/*indexName+"/"+*/
        sphinx_search_const::searchdPidFileName+"_"+indexName+"."+
        sphinx_search_const::searchdPidFileExt;
    pConf->setString(sphinx_search_const::searchdPidName, value);

    value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdQueryLogFile;
    pConf->setString(sphinx_search_const::searchdQueryLogName, value);

    pConf->save(propFile);
    pConf->setPropertyFileConfiguration(propFile);

    std::ofstream ofs(sphinxConfigFile.c_str(), std::fstream::trunc);
    ofs << *pConf;
    ofs.close();

    // apply property options to config
    writePropertyOptions(*pConf, configOptions);
    pConf->save(propFile);

    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    fObj.log() << message(message_const::ERROR_MAKE_CONFIG, errorMsg) << std::endl;
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxAdminCommand::isExistError(const std::string& procExecMsg)
{
  return ((procExecMsg.find(sphinx_admin_command_const::procExecErrorMsg)!=std::string::npos) ||
      (procExecMsg.find(sphinx_admin_command_const::procExecFatalMsg)!=std::string::npos));
}
//-----------------------------------------------------------------------------
std::string SphinxAdminCommand::getPropertyFileName(const std::string& indexPath, const std::string& branchName)
{
  return indexPath+"/"+sphinx_admin_command_const::dataDir+"/"+branchName+"_"+sphinx_search_const::branchPropertyFile;
}
//-----------------------------------------------------------------------------
std::string SphinxAdminCommand::getConfigFileName(const std::string& indexPath, const std::string& branchName)
{
  return indexPath+"/"+sphinx_admin_command_const::dataDir+"/"+branchName+"_"+sphinx_search_const::branchConfigFile;
}
//-----------------------------------------------------------------------------
void SphinxAdminCommand::writePropertyOptions(SphinxConfigCreator& configCreator, const SphinxConfigOptions& configOptions)
{
  configCreator.setUInt64(sphinx_admin_command_const::optionsMaxDocId, configOptions.getMaxDocId());
  configCreator.setUInt64(sphinx_admin_command_const::optionsCreatedDate, configOptions.getCreatedDate());
  configCreator.setUInt64(sphinx_admin_command_const::optionsMergedDate, configOptions.getMergedDate());
  configCreator.setString(sphinx_admin_command_const::optionsBranches, configOptions.getBranchesAsString());
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
Poco::SharedPtr<SphinxAdminCommand> SphinxAdminCommandFactory::create(SphinxFunctionalObject& fObj, const std::string& commandString)
{
  Poco::SharedPtr<SphinxAdminCommand> pCmd;

  if (commandString == "INDEX_CREATE")
    pCmd = new IndexCreate(fObj);
  else if (commandString == "INDEX_CHECK")
    pCmd = new IndexCheck(fObj);
  else if (commandString == "INDEX_STORE_DATA_FILE")
    pCmd = new IndexStoreDataFile(fObj);
  else if (commandString == "INDEX_STORE_SCHEMA_FILE")
    pCmd = new IndexStoreSchemaFile(fObj);
  else if (commandString == "INDEX_REBUILD")
    pCmd = new IndexRebuild(fObj);
//  else if (commandString == "INDEX_SET_DATA_DIR") // not use
//    pCmd = new IndexSetDataDir(fObj);
  else if (commandString == "INDEX_START")
    pCmd = new IndexStart(fObj);
  else if (commandString == "INDEX_STOP")
    pCmd = new IndexStop(fObj);
  else if (commandString == "INDEX_MERGE")
    pCmd = new IndexMerge(fObj);
  else if (commandString == "INDEX_MERGE_TRUNK")
    pCmd = new IndexMergeTrunk(fObj);
  else if (commandString == "INDEX_DELETE_DATA_FILE")
    pCmd = new IndexDeleteDataFile(fObj);
  else if (commandString == "INDEX_DELETE_SCHEMA_FILE")
    pCmd = new IndexDeleteSchemaFile(fObj);
  else if (commandString == "INDEX_APPEND_DATA_FILE")
    pCmd = new IndexAppendDataFile(fObj);
  else if (commandString == "INDEX_DELETE_DOC")
    pCmd = new IndexDeleteDoc(fObj);
  else if (commandString == "INDEX_DELETE_DOC_NUMBER")
    pCmd = new IndexDeleteDocNumber(fObj);
  else if (commandString == "INDEX_PACK_DOC_DATA")
    pCmd = new IndexPackDocData(fObj);
  else if (commandString == "INDEX_REMOVE")
    pCmd = new IndexRemove(fObj);
  else if (commandString == "INDEX_COPY")
    pCmd = new IndexCopy(fObj);
  else if (commandString == "INDEX_RENAME")
    pCmd = new IndexRename(fObj);
  else if (commandString == "INDEX_SET_CONFIG_VAR")
    pCmd = new IndexSetConfigVar(fObj);
  else if (commandString == "INDEX_GET_CONFIG_VAR")
    pCmd = new IndexGetConfigVar(fObj);
  else if (commandString == "INDEX_CHECK_SCHEMA")
    pCmd = new IndexCheckSchema(fObj);
  else if (commandString == "INDEX_STATUS_SEARCHD")
    pCmd = new IndexStatusSearchd(fObj);
  else if (commandString == "INDEX_STATUS")
    pCmd = new IndexStatus(fObj);
  else if (commandString == "INDEX_MAX_DOC_ID")
    pCmd = new IndexMaxDocId(fObj);
  else if (commandString == "INDEX_DATA_LIST")
    pCmd = new IndexDataList(fObj);
  else if (commandString == "INDEX_BRANCHES_LIST")
    pCmd = new IndexBranchesList(fObj);
  else if (commandString == "INDEX_BRANCHES_INFO")
    pCmd = new IndexBranchesInfo(fObj);
  else if (commandString == "INDEX_BRANCHES_STATUS")
    pCmd = new IndexBranchesStatus(fObj);
  else if (commandString == "INDEX_CONNECT")
    pCmd = new IndexConnect(fObj);
  else if (commandString == "INDEX_DISCONNECT")
    pCmd = new IndexDisconnect(fObj);

  return pCmd;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexCreate::IndexCreate(SphinxFunctionalObject& fObj)
:inherited(fObj), indexName("")
{
}
//-----------------------------------------------------------------------------
bool IndexCreate::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexName, indexName);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexCreate::unserialize(const std::string& json)
{
  indexName.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexCreate::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;

    if (isExistDir(path))
      throw Poco::Exception(message(message_const::INDEX_ALREADY_EXIST, indexName), ERROR_CREATE_INDEX);

    unsigned int allowedPort = sphinx_search_const::defaultPort;

    if (!getFreeAllowedPort(allowedPort))
      throw Poco::Exception(errorMsg, ERROR_CREATE_INDEX);

    if (!makeDir(path))
      throw Poco::Exception(message(message_const::MAKE_DIR_FAIL, path)+message(message_const::ERROR, errorMsg), ERROR_CREATE_INDEX);

    std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;
    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;

    if (!makeDir(indexDir))
      throw Poco::Exception(message(message_const::MAKE_DIR_FAIL, indexDir)+message(message_const::ERROR, errorMsg), ERROR_CREATE_INDEX);

    if (!makeDir(dataDir))
      throw Poco::Exception(message(message_const::MAKE_DIR_FAIL, dataDir)+message(message_const::ERROR, errorMsg), ERROR_CREATE_INDEX);

    if (!isExistDir(indexDir))
      throw Poco::Exception("Don't created index dir: '"+indexDir+"'", ERROR_CREATE_INDEX);

    if (!isExistDir(dataDir))
      throw Poco::Exception("Don't created data dir: '"+dataDir+"'", ERROR_CREATE_INDEX);

    std::string srcFile = fObj.getEtcDir()+"/"+sphinx_search_const::sphinxSchemaFile;
    std::string dstFile = path+"/"+sphinx_search_const::sphinxSchemaFile;

    if (copyFile(srcFile, dstFile))
    {
      srcFile = fObj.getEtcDir()+"/"+sphinx_search_const::sphinxTemplateFile;
      dstFile = path+"/"+sphinx_search_const::sphinxPropertyFile;

      Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(srcFile);

      std::vector<std::string> keys;
      pConf->keys(keys);

      for (size_t i=0;i<keys.size();++i)
      {
        if (keys[i].find(sphinx_search_const::sourceNameField)!=std::string::npos)
        {
          std::string name = keys[i]+"."+sphinx_search_const::xmlpipeCommandNameField;
          std::string value = pConf->getString(name);
          size_t pos = value.find_last_of(' ');
          if (pos!=std::string::npos)
            value = value.substr(pos+1);

          std::stringstream str;
          str << "cat " << dataDir << '/' << value;
          pConf->setString(name, str.str());
        }

        if (keys[i].find(sphinx_search_const::indexNameField)!=std::string::npos)
        {
          std::string name = keys[i]+"."+sphinx_search_const::pathNameField;
          std::string value = pConf->getString(name);

          std::stringstream str;
          str << indexDir << '/' << value;
          pConf->setString(name, str.str());
        }
      }
      // create structure run dir
      std::string runDir = fObj.getRunDir();
      if (!isExistDir(runDir))
        if (!makeDir(runDir))
          throw Poco::Exception(message(message_const::DONT_CREATED_DIR, runDir)+message(message_const::ERROR, errorMsg), ERROR_CREATE_INDEX);

      // create structure log dir
      std::string logDir = fObj.getLogDir();
      if (!isExistDir(logDir))
        if (!makeDir(logDir))
          throw Poco::Exception(message(message_const::DONT_CREATED_DIR, logDir)+message(message_const::ERROR, errorMsg), ERROR_CREATE_INDEX);

      logDir = fObj.getLogDir()+"/"+indexName;
      if (!isExistDir(logDir))
        if (!makeDir(logDir))
          throw Poco::Exception(message(message_const::DONT_CREATED_DIR, logDir)+message(message_const::ERROR, errorMsg), ERROR_CREATE_INDEX);

      // create content of property file
      std::string value = logDir+"/"+sphinx_search_const::searchdLogFile;
      pConf->setString(sphinx_search_const::searchdLogName, value);

      value = logDir+"/"+sphinx_search_const::searchdQueryLogFile;
      pConf->setString(sphinx_search_const::searchdQueryLogName, value);

      value = runDir+"/"+sphinx_search_const::searchdPidFileName+"_"+indexName+"."+sphinx_search_const::searchdPidFileExt;  // make pid file name
      pConf->setString(sphinx_search_const::searchdPidName, value);

      value = fObj.getServerHost()+":"+std::to_string(allowedPort);
      pConf->setString(sphinx_search_const::searchdListen, value);

      pConf->save(dstFile);
      pConf->setPropertyFileConfiguration(dstFile);

      std::string sphinxConfig = path+"/"+sphinx_search_const::sphinxConfigName;
      std::ofstream ofs(sphinxConfig.c_str(), std::fstream::trunc);
      ofs << *pConf;
      ofs.close();

      SphinxConfigOptions configOptions;
      writePropertyOptions(*pConf, configOptions);
      pConf->save(dstFile);
      pConf->setPropertyFileConfiguration(dstFile);

      _isError = false;
    }
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexCheck::IndexCheck(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexCheck::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, path), ERROR_CHECK_INDEX);

    if (!isExistDir(path+"/"+sphinx_admin_command_const::indexDir))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, path+"/"+sphinx_admin_command_const::indexDir), ERROR_CHECK_INDEX);

    if (!isExistDir(path+"/"+sphinx_admin_command_const::dataDir))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, path+"/"+sphinx_admin_command_const::dataDir), ERROR_CHECK_INDEX);

    if (!isExistDir(fObj.getLogDir()+"/"+indexName))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, fObj.getLogDir()+"/"+indexName), ERROR_CHECK_INDEX);

    if (!isExistDir(fObj.getRunDir()))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, fObj.getRunDir()), ERROR_CHECK_INDEX);

    if (!isExistFile(path+"/"+sphinx_search_const::sphinxConfigName))
      throw Poco::Exception(message(message_const::FILE_NOT_EXIST, path+"/"+sphinx_search_const::sphinxConfigName), ERROR_CHECK_INDEX);

    if (!isExistFile(path+"/"+sphinx_search_const::sphinxSchemaFile))
      throw Poco::Exception(message(message_const::FILE_NOT_EXIST, path+"/"+sphinx_search_const::sphinxSchemaFile), ERROR_CHECK_INDEX);

    if (!isExistFile(path+"/"+sphinx_search_const::sphinxPropertyFile))
          throw Poco::Exception(message(message_const::FILE_NOT_EXIST, path+"/"+sphinx_search_const::sphinxPropertyFile), ERROR_CHECK_INDEX);

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    resultData = "0";
    errorMsg = e.message();
    errorCode = e.code();
  }
  resultData = (!_isError)?"1":"0";
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexStoreDataFile::IndexStoreDataFile(SphinxFunctionalObject& fObj)
: inherited(fObj), indexName(""), branchName(""), dataContent("")
{
}
//-----------------------------------------------------------------------------
bool IndexStoreDataFile::serialize(std::string& json)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexName, indexName);
    obj->set(sphinx_admin_command_const::branchName, branchName);
    obj->set(sphinx_admin_command_const::dataContent, dataContent);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexStoreDataFile::unserialize(const std::string& json)
{
  indexName.clear();
  branchName.clear();
  dataContent.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::branchName);
    if (tmp.isString())
      branchName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::dataContent);
    if (tmp.isString())
      dataContent = tmp.convert<std::string>();

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexStoreDataFile::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, path), ERROR_STORE_DATA_FILE);

    path.append("/").append(sphinx_admin_command_const::dataDir);
    if (!isExistDir(path))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, path), ERROR_STORE_DATA_FILE);

    std::stringstream str(HCE::decodeBase64(dataContent));
    if (str.str().empty())
      throw Poco::Exception(message(message_const::INVALID_DATA_CONTENT), ERROR_STORE_DATA_FILE);

    if (fObj.getCheckIncomingDocuments())
    {
      SphinxDataFile dataFile;
      dataFile.validateData(str);
      if (dataFile.isError())
        throw Poco::Exception(dataFile.getErrorMsg(), ERROR_STORE_DATA_FILE);
    }

    if (fObj.getPackIncomingDocuments())
    {
      XMLCleaner xmlCleaner(sphinx_data_source_const::docsetTag,
                            sphinx_data_source_const::documentTag,
                            sphinx_data_source_const::documentIdAttrTag);

      std::set<std::string> delList;
      std::string outString = xmlCleaner.process(str.str(), delList);
      str.str(outString);
    }

    path.append("/").append(branchName).append(".dat");

    std::ofstream ofs(path.c_str(), std::fstream::trunc);
    if (!ofs.is_open())
      throw Poco::Exception(message(message_const::FILE_NOT_OPEN, path), ERROR_STORE_DATA_FILE);

    ofs << str.str();
    ofs.close();
    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.displayText();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_STORE_DATA_FILE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexStoreSchemaFile::IndexStoreSchemaFile(SphinxFunctionalObject& fObj)
: inherited(fObj), indexName(""), schemaContent("")
{
}
//-----------------------------------------------------------------------------
bool IndexStoreSchemaFile::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexName, indexName);
    obj->set(sphinx_admin_command_const::dataContent, schemaContent);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexStoreSchemaFile::unserialize(const std::string& json)
{
  indexName.clear();
  schemaContent.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::dataContent);
    if (tmp.isString())
      schemaContent = tmp.convert<std::string>();

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexStoreSchemaFile::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, path), ERROR_STORE_SCHEMA_FILE);

    std::stringstream str(HCE::decodeBase64(schemaContent));
    if (str.str().empty())
      throw Poco::Exception(message(message_const::INVALID_DATA_CONTENT), ERROR_STORE_SCHEMA_FILE);

    if (fObj.getCheckIncomingDocuments())
    {
      SphinxSchemaFile schemaFile(str);
      std::vector<std::pair<std::string, int> > schemaVec;
      if (!schemaFile.getFields(schemaVec))
        throw Poco::Exception(message(message_const::INVALID_SCHEMA_CONTENT)+message(message_const::ERROR, schemaFile.getErrorMsg()), ERROR_STORE_SCHEMA_FILE);
    }
    path.append("/").append(sphinx_search_const::sphinxSchemaFile);

    std::ofstream ofs(path.c_str(), std::fstream::trunc);
    if (!ofs.is_open())
      throw Poco::Exception(message(message_const::FILE_NOT_OPEN, path), ERROR_STORE_SCHEMA_FILE);

    ofs << HCE::decodeBase64(schemaContent);
    ofs.close();
    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexRebuild::IndexRebuild(SphinxFunctionalObject& fObj)
: inherited(fObj), indexName(""), branches()
{
}
//-----------------------------------------------------------------------------
bool IndexRebuild::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexName, indexName);

    Poco::JSON::Array::Ptr vecBranches = new Poco::JSON::Array();
    obj->set(sphinx_admin_command_const::branches, vecBranches);

    for (size_t i=0;i<branches.size();++i)
      vecBranches->add(branches[i]);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexRebuild::unserialize(const std::string& json)
{
  indexName.clear();
  branches.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

    Poco::JSON::Array::Ptr vecBranches = obj->getArray(sphinx_admin_command_const::branches);
    if (!vecBranches.isNull())
    {
      for (size_t k = 0;k<vecBranches->size();++k)
      {
        Poco::Dynamic::Var tmp = vecBranches->get(k);
        if (tmp.isString())
        {
          std::string branchName = tmp.convert<std::string>();
          if (isAllowedString(branchName))
            branches.push_back(branchName);
          else
          {
            errorMsg = message(message_const::BAD_BRANCH_NAME);
            errorCode = ERROR_BRANCH_NAME;
            if (!resultData.empty())
              resultData.append(",");
            resultData.append(branchName);
          }
        }
      }
    }

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexRebuild::makeSource(const std::string& schemaFile, const std::string& branchName, const std::string& sourcePath, const std::string& configPath)
{
  bool result = false;
  try
  {
    std::ifstream ifsSchema(schemaFile.c_str());
    if (!ifsSchema.is_open())
      throw Poco::Exception(message(message_const::FILE_NOT_OPEN, schemaFile), ERROR_MAKE_SOURCE);

    std::string dataFileName = sourcePath+"/"+branchName+"."+sphinx_admin_command_const::dataFileExtension;
    std::ifstream ifsDoc(dataFileName.c_str());
    if (!ifsDoc.is_open())
    {
      ifsSchema.close();
      throw Poco::Exception(message(message_const::FILE_NOT_OPEN, dataFileName), ERROR_MAKE_SOURCE);
    }

    std::string outputFileName = sourcePath+"/"+branchName+"."+sphinx_admin_command_const::sourceFileExtension;

    SphinxDataSource dataSource(ifsSchema, ifsDoc);
    std::fstream outputSource(outputFileName.c_str(), std::fstream::out | std::fstream::trunc);
    try
    {
      outputSource << dataSource << std::endl;
      result = makeIndex(outputFileName, branchName, configPath, dataSource.getMaxDocId());
    }
    catch(Poco::Exception& e)
    {
      errorMsg = message(message_const::MAKE_SOURCE_FAIL, outputFileName)+message(message_const::ERROR, e.message());
      errorCode = ERROR_MAKE_SOURCE;
    }
    outputSource.close();
    ifsDoc.close();
    ifsSchema.close();
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
    fObj.log() << message(message_const::MAKE_SOURCE) << errorMsg << std::endl;
  }
  return result;
}
//-----------------------------------------------------------------------------
bool IndexRebuild::makeIndex(const std::string& sourceFile, const std::string& branchName, const std::string& configPath, unsigned long long maxDocId)
{
  const std::string propertyFile = getPropertyFileName(configPath, branchName);
  const std::string configFile = getConfigFileName(configPath, branchName);
  const std::string propFile = configPath+"/"+sphinx_search_const::sphinxPropertyFile;
  bool result = false;
  try
  {
    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);

    SphinxConfigOptions configOptions;
    configOptions.setMaxDocId(maxDocId);
    configOptions.addBranch(branchName);
    configOptions.setCreatedDate(pConf->getUInt64(sphinx_admin_command_const::optionsCreatedDate, 0));

    pConf->remove(sphinx_admin_command_const::sectionOptions);

    std::vector<std::string> keys;
    pConf->keys(keys);

    std::string sectionName;
    for (size_t i=0;i<keys.size();++i)
    {
      if (keys[i].find(sphinx_search_const::sourceNameField)!=std::string::npos)
      {
        std::string name = keys[i]+"."+sphinx_search_const::xmlpipeCommandNameField;
        std::stringstream str;
        str << "cat " << sourceFile;
        pConf->setString(name, str.str());
      }
      if (keys[i].find(sphinx_search_const::indexNameField)!=std::string::npos)
      {
        std::string name = keys[i]+"."+sphinx_search_const::pathNameField;
        std::stringstream str;
        str << configPath+"/"+sphinx_admin_command_const::indexDir << "/" << branchName;
        pConf->setString(name, str.str());
        sectionName = keys[i];
      }
    }

    pConf->save(propertyFile);
    pConf->setPropertyFileConfiguration(propertyFile);
    pConf->renameSphinxConfigSection(sectionName, "index "+branchName);

    std::ofstream ofs(configFile.c_str(), std::fstream::trunc);
    ofs << *pConf;
    ofs.close();

    pConf->clear();
    pConf->setPropertyFileConfiguration(propertyFile);
    pConf->cloneSphinxConfigSection(sectionName, "index "+branchName);
    pConf->remove(sectionName);

    writePropertyOptions(*pConf, configOptions);
    pConf->save(propertyFile);

    std::stringstream outMsg, errMsg;
    const std::string cmd("indexer --config " +configFile+" --all");
    fObj.log() << message(message_const::COMMAND_LINE, cmd) << std::endl;

    ProcExec procExec(cmd);
    if (!procExec.exec(outMsg, errMsg))
      throw Poco::Exception(message(message_const::INDEXATION_FAIL, branchName)+message(message_const::ERROR, errMsg.str()));

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str());

    fObj.log() << outMsg.str() << std::endl;
    result = true; // (removeFile(propertyFile) && removeFile(configFile));
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_MAKE_INDEX;
    fObj.log() << message(message_const::MAKE_INDEX) << errorMsg << std::endl;
  }
  return result;
}
//-----------------------------------------------------------------------------
bool IndexRebuild::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (branches.empty())
      throw Poco::Exception(message(message_const::RECEIVED_EMPTY_LIST_BRANCHES), ERROR_COMMAND_INITIALIZATION);

    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception(message(message_const::FOLDER_NOT_EXIST, path), ERROR_INDEX_REBUILD);

    std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;
    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;

    if (!isExistDir(path+"/"+sphinx_admin_command_const::indexDir))
      throw Poco::Exception("Forder: '"+path+"/"+sphinx_admin_command_const::indexDir+"' not exists", ERROR_INDEX_REBUILD);

    if (!isExistDir(path+"/"+sphinx_admin_command_const::dataDir))
      throw Poco::Exception("Forder: '"+path+"/"+sphinx_admin_command_const::dataDir+"' not exists", ERROR_INDEX_REBUILD);

    const std::string schemaFileName = path+"/"+sphinx_search_const::sphinxSchemaFile;
    std::vector<std::string> vFiles;
    if (getFileList(dataDir, vFiles, sphinx_admin_command_const::dataFileExtension))
    {
      unsigned int madeFailCount = 0;
      if (vFiles.size()==0)
      {
        throw Poco::Exception("Empty list of files data", ERROR_INDEX_REBUILD);
      }
      else if (branches.front()=="*")
      {
        if (!cleanDir(indexDir))
          throw Poco::Exception(errorMsg, errorCode);

        for (size_t i=0;i<vFiles.size();++i)
        {
          if (!makeSource(schemaFileName, vFiles[i], dataDir, path))
          {
            if (!resultData.empty())
              resultData.append(",");
            resultData.append(vFiles[i]);
            ++madeFailCount;
          }
        }
      }
      else
      {
        for (size_t k=0;k<branches.size();++k)
          for (size_t i=0;i<vFiles.size();++i)
            if (vFiles[i]==branches[k])
            {
              if (!makeSource(schemaFileName, vFiles[i], dataDir, path))
              {
                if (!resultData.empty())
                  resultData.append(",");
                resultData.append(vFiles[i]);
                ++madeFailCount;
              }
              break;
            }
      }
      if (madeFailCount==0)
        _isError = false;
    }
    if (_isError)
      throw Poco::Exception(errorMsg, ERROR_INDEX_REBUILD);
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexSetDataDir::IndexSetDataDir(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexSetDataDir::serialize(std::string& json)
{
  //TODO
  return false;
}
//-----------------------------------------------------------------------------
bool IndexSetDataDir::unserialize(const std::string& json)
{
  //TODO
  return false;
}
//-----------------------------------------------------------------------------
bool IndexSetDataDir::execute(void)
{
  //TODO
  return false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexStart::IndexStart(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexStart::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (indexName.empty())
      indexName = fObj.getIndexName();

    // check and create if need  structure run dir
    std::string runDir = fObj.getRunDir();
    if (!isExistDir(runDir))
      if (!makeDir(runDir))
        throw Poco::Exception("Don't created run dir: '"+runDir+"'", ERROR_INDEX_START);

    // check and create if need structure log dir
    std::string logDir = fObj.getLogDir();
    if (!isExistDir(logDir))
      if (!makeDir(logDir))
        throw Poco::Exception("Don't created log dir: '"+logDir+"'", ERROR_INDEX_START);

    // check and create if need structure log dir / index name
    logDir = fObj.getLogDir()+"/"+indexName;
    if (!isExistDir(logDir))
      if (!makeDir(logDir))
        throw Poco::Exception("Don't created default index log dir: '"+logDir+"'", ERROR_INDEX_START);

    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_START);

    path.append("/").append(sphinx_search_const::sphinxConfigName);
    if (!isExistFile(path))
      throw Poco::Exception("Config file '"+path+"' not exist", ERROR_INDEX_START);

    fObj.setIndexName(indexName);
    if (fObj.loadConfiguration(indexName))
    {
      bool isRunSearchd = fObj.isActiveSearchd();
      fObj.log() << "isRunSearchd = " << std::boolalpha << isRunSearchd << std::endl;
      fObj.log() << "IndexName: " << fObj.getIndexName() << std::endl;

      if (isRunSearchd)
      {
        fObj.log() << "STOPED Searchd: " << std::boolalpha << fObj.stopSearchd() << std::endl;
      }
      if (!fObj.startSearchd())
        throw Poco::Exception(fObj.getErrorMsg(), fObj.getErrorCode());

      _isError = false;
    }
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexStop::IndexStop(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexStop::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;

  try
  {
    if (indexName!=fObj.getIndexName())
      throw Poco::Exception("Index '"+indexName+"' not started", ERROR_INDEX_STOP);

    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_STOP);

    path.append("/").append(sphinx_search_const::sphinxConfigName);
    if (!isExistFile(path))
      throw Poco::Exception("Config file '"+path+"' not exist", ERROR_INDEX_STOP);

    if (!fObj.stopSearchd())
      throw Poco::Exception(fObj.getErrorMsg(), fObj.getErrorCode());

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexMerge::IndexMerge(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexMerge::makeMerge(const std::string& branchName, const std::string& configPath, const std::string& trunkName, unsigned long long& maxDocId)
{
  bool result = false;
  const std::string propertyFile = configPath+"/"+sphinx_search_const::branchPropertyFile;
  const std::string configFile = configPath+"/"+sphinx_search_const::branchConfigFile;
  const std::string propFile = configPath+"/"+sphinx_search_const::sphinxPropertyFile;
  try
  {
    Poco::AutoPtr<SphinxConfigCreator> pConfBranch = new SphinxConfigCreator(getPropertyFileName(configPath, branchName));
    maxDocId = pConfBranch->getUInt64(sphinx_admin_command_const::optionsMaxDocId, 0);

    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);
    pConf->remove(sphinx_admin_command_const::sectionOptions);

    std::vector<std::string> keys;
    pConf->keys(keys);

    const std::string sourceFile = configPath+"/"+sphinx_admin_command_const::dataDir+"/"+branchName+"."+sphinx_admin_command_const::sourceFileExtension;

    std::string trunkSectionName, branchSource;
    for (size_t i=0;i<keys.size();++i)
    {
      size_t found = keys[i].find(sphinx_search_const::sourceNameField);
      if (found!=std::string::npos)
      {
        branchSource = keys[i];

        std::string name = keys[i]+"."+sphinx_search_const::xmlpipeCommandNameField;
        std::stringstream str;
        str << "cat " << sourceFile;
        pConf->setString(name, str.str());
      }
      if (keys[i].find(sphinx_search_const::indexNameField)!=std::string::npos && keys[i].find(trunkName)!=std::string::npos)
      {
        trunkSectionName = keys[i];
      }
    }
    if (trunkSectionName.empty())
      throw Poco::Exception("Section name: '"+trunkSectionName+"' not valid");

    std::string branchSectionName = sphinx_search_const::indexNameField+" "+branchName;
    pConf->cloneSphinxConfigSection(trunkSectionName, branchSectionName);

    std::string branchSourceName = branchSource;
    std::string trunkSourceName = sphinx_search_const::sourceNameField+" "+trunkName;
    pConf->cloneSphinxConfigSection(branchSourceName, trunkSourceName);

    std::string name = trunkSectionName+"."+sphinx_search_const::sourceNameField;
    std::string value = trunkSourceName;
    pConf->setString(name, value);

    name = trunkSourceName+"."+sphinx_search_const::xmlpipeCommandNameField;
    value = "echo \"\"";
    pConf->setString(name, value);

    name = branchSectionName+"."+sphinx_search_const::pathNameField;
    value = configPath+"/"+sphinx_admin_command_const::indexDir+"/"+branchName;
    pConf->setString(name, value);

    name = trunkSectionName+"."+sphinx_search_const::pathNameField;
    value = configPath+"/"+sphinx_admin_command_const::indexDir+"/"+trunkName;
    pConf->setString(name, value);

    value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdLogFile;
    pConf->setString(sphinx_search_const::searchdLogName, value);

    value = fObj.getRunDir()+"/"+/*indexName+"/"+*/
        sphinx_search_const::searchdPidFileName+"_"+indexName+"."+
        sphinx_search_const::searchdPidFileExt;
    pConf->setString(sphinx_search_const::searchdPidName, value);

    value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdQueryLogFile;
    pConf->setString(sphinx_search_const::searchdQueryLogName, value);

    pConf->save(propertyFile);
    pConf->setPropertyFileConfiguration(propertyFile);

    std::ofstream ofs(configFile.c_str(), std::fstream::trunc);
    ofs << *pConf;
    ofs.close();

    std::stringstream outMsg;
    const std::string cmd("indexer");
    std::vector<std::string> args = {"--merge", trunkName, branchName, "--config", configFile};
    ProcExec procExec(cmd, args);
    bool ret = procExec.exec(outMsg, outMsg);

    if (!(removeFile(configFile) && removeFile(propertyFile)))
      throw Poco::Exception(errorMsg);

    if (!ret)
      throw Poco::Exception("Merge '"+branchName+"' to '"+trunkName+"' fail");

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str());

    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_MAKE_MERGE;
    fObj.log() << "ERROR_MAKE_MERGE " << errorMsg << std::endl;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_MAKE_MERGE;
    fObj.log() << "ERROR_MAKE_MERGE " << errorMsg << std::endl;
  }

  return result;
}
//-----------------------------------------------------------------------------
bool IndexMerge::makeTrunk(const std::string& trunkName, const std::string& configPath,
    std::vector<std::string>& vIndexes, unsigned long long& maxDocId) throw (Poco::Exception)
{
  if (vIndexes.empty())
    throw Poco::Exception("Empty list of existing indexes", ERROR_MAKE_TRUNK_INDEX);

  bool result = true;
  for (size_t i=0;i<vIndexes.size();++i)
  {
    if (vIndexes[i]==trunkName)
    {
      result = false;
      break;
    }
  }

  if (result)
  {
    const std::string propertyFile = configPath+"/"+sphinx_search_const::branchPropertyFile;
    const std::string configFile = configPath+"/"+sphinx_search_const::branchConfigFile;
    const std::string propFile = configPath+"/"+sphinx_search_const::sphinxPropertyFile;

    try
    {
      Poco::AutoPtr<SphinxConfigCreator> pConfBranch = new SphinxConfigCreator(getPropertyFileName(configPath, vIndexes.front()));
      maxDocId = pConfBranch->getUInt64(sphinx_admin_command_const::optionsMaxDocId, 0);

      Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);
      pConf->remove(sphinx_admin_command_const::sectionOptions);

      std::vector<std::string> keys;
      pConf->keys(keys);

      for (size_t i=0;i<keys.size();++i)
      {
        if (keys[i].find(sphinx_search_const::sourceNameField)!=std::string::npos)
        {
          std::string name = keys[i]+"."+sphinx_search_const::xmlpipeCommandNameField;
          std::stringstream str;
          str << "cat " << configPath+"/"+sphinx_admin_command_const::dataDir << "/" << vIndexes.front() << "."
              << sphinx_admin_command_const::sourceFileExtension;
          pConf->setString(name, str.str());
        }
        if (keys[i].find(sphinx_search_const::indexNameField)!=std::string::npos && keys[i].find(trunkName)!=std::string::npos )
        {
          std::string name = keys[i]+"."+sphinx_search_const::pathNameField;
          std::stringstream str;
          str << configPath+"/"+sphinx_admin_command_const::indexDir << "/" << trunkName;
          pConf->setString(name, str.str());
        }
      }
      std::string value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdLogFile;
      pConf->setString(sphinx_search_const::searchdLogName, value);

      value = fObj.getRunDir()+"/"+/*indexName+"/"+*/
          sphinx_search_const::searchdPidFileName+"_"+indexName+"."+
          sphinx_search_const::searchdPidFileExt;
      pConf->setString(sphinx_search_const::searchdPidName, value);

      value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdQueryLogFile;
      pConf->setString(sphinx_search_const::searchdQueryLogName, value);

      pConf->save(propertyFile);
      pConf->setPropertyFileConfiguration(propertyFile);

      std::ofstream ofs(configFile.c_str(), std::fstream::trunc);
      ofs << *pConf;
      ofs.close();

      std::stringstream outMsg;
      const std::string cmd("indexer");
      std::vector<std::string> args = {"--quiet", trunkName, "--config", configFile};
      ProcExec procExec(cmd, args);
      bool ret = procExec.exec(outMsg, outMsg);

      if (!(removeFile(configFile) && removeFile(propertyFile)))
        throw Poco::Exception(errorMsg);

      if (!ret)
        throw Poco::Exception("Indexation '"+trunkName+"' fail");

      if (isExistError(outMsg.str()))
        throw Poco::Exception(outMsg.str());

      vIndexes.erase(vIndexes.begin());
    }
    catch(Poco::Exception& e)
    {
      fObj.log() << "ERROR_MAKE_TRUNK_INDEX " << e.message() << std::endl;
      throw Poco::Exception(e.message(), ERROR_MAKE_TRUNK_INDEX);
    }
  }
  return result;
}
//-----------------------------------------------------------------------------
bool IndexMerge::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  fObj.log() << "IndexMerge::execute enter...." << std::endl;
  try
  {
    if (indexName.empty())
      throw Poco::Exception("Received empty index name", ERROR_COMMAND_INITIALIZATION);

    if (branches.empty())
      throw Poco::Exception("Received empty list of branches", ERROR_COMMAND_INITIALIZATION);

    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_MERGE);

    std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;
    if (!isExistDir(indexDir))
      throw Poco::Exception("Forder: '"+indexDir+"' not exists", ERROR_INDEX_MERGE);

    SphinxFunctionalObject fObject("", fObj.getHomeDir(), indexName);
    if (!fObject.isLoadedConfig())
      throw Poco::Exception(fObject.getErrorMsg(), ERROR_INDEX_MERGE);

    fObject.setLogStream(fObj.log());
    fObj.log() << "removeIndexFile fObject.getIndexFileName() = " << fObject.getIndexFileName() << std::endl;

    if (!removeIndexFile(fObject.getIndexFileName(), indexDir))
      throw Poco::Exception(errorMsg, errorCode);

    std::vector<std::string> vIndexes;
    if (getIndexList(indexDir, vIndexes))
    {
//      fObj.log() << "getIndexList vIndexes.size() = " << vIndexes.size() << std::endl;

      if (vIndexes.empty())
        throw Poco::Exception("Empty indexes list", ERROR_INDEX_MERGE);

      SphinxConfigOptions configOptions;
      unsigned long long maxDocId = 0;
      unsigned long long branchMaxDocId = 0;

      const std::string trunkFileName = *(vIndexes.begin());
      bool isMadeTrunk = makeTrunk(fObject.getIndexFileName(), path, vIndexes, maxDocId);

 //     fObj.log() << "Trunk File Name = " << trunkFileName << std::endl;
      fObj.log() << "Prepare merge. Make " << fObj.getIndexFileName() << " => " << std::boolalpha << isMadeTrunk << std::endl;
      configOptions.addBranch(trunkFileName);

      unsigned int madeFailCount = 0;
      if (branches.front()=="*")
      {
        for (size_t i=0;i<vIndexes.size();++i)
        {
          if (!makeMerge(vIndexes[i], path, fObject.getIndexFileName(), branchMaxDocId))
          {
            if (!resultData.empty())
              resultData.append(",");
            resultData.append(vIndexes[i]);
            ++madeFailCount;
          }
          else
          {
            configOptions.addBranch(vIndexes[i]);
            if (maxDocId < branchMaxDocId)
              maxDocId = branchMaxDocId;
          }
        }
      }
      else
      {
        for (size_t k=0;k<branches.size();++k)
          for (size_t i=0;i<vIndexes.size();++i)
            if (vIndexes[i]==branches[k])
            {
              if (!makeMerge(vIndexes[i], path, fObject.getIndexFileName(), branchMaxDocId))
              {
                if (!resultData.empty())
                  resultData.append(",");
                resultData.append(vIndexes[i]);
                ++madeFailCount;
              }
              else
              {
                configOptions.addBranch(vIndexes[i]);
                if (maxDocId < branchMaxDocId)
                  maxDocId = branchMaxDocId;
              }
              break;
            }
      }

      bool isActive = fObject.isActiveSearchd();   // save state of daemon
      fObject.stopSearchd();

      fObj.log() << "IndexFileName = " << fObj.getIndexFileName() << std::endl;
      fObj.log() << "IS ACTIVE SEARCHD => " << std::boolalpha << isActive << std::endl;

      if (!moveIndexFiles(fObject.getIndexFileName(), indexDir, path))
        throw Poco::Exception("move file: "+errorMsg, ERROR_INDEX_MERGE);

      configOptions.setMaxDocId(maxDocId);
      configOptions.updateMargedDate();

      if (!makeTrunkConfig(fObject.getIndexFileName(), indexName, trunkFileName, configOptions))
        throw Poco::Exception("make config: "+errorMsg, ERROR_INDEX_MERGE);

      fObj.log() << "FO IndexName: " << fObj.getIndexName() << std::endl;
      fObj.log() << "Current IndexName: " << indexName << std::endl;

      if (isActive) // restore source state
        if (!fObject.startSearchd())
          throw Poco::Exception("Index Merge fail. ", ERROR_INDEX_MERGE);

      if (madeFailCount==0)
        _isError = false;
    }
    if (_isError)
      throw Poco::Exception(errorMsg, ERROR_INDEX_MERGE);
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
    _isError = true;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_INDEX_MERGE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexMergeTrunk::IndexMergeTrunk(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexMergeTrunk::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  fObj.log() << "\n***********\nIndexMergeTrunk::execute enter...." << std::endl;
  try
  {
    if (indexName.empty())
      throw Poco::Exception("Received empty index name", ERROR_COMMAND_INITIALIZATION);

    if (branches.empty())
      throw Poco::Exception("Received empty list of branches", ERROR_COMMAND_INITIALIZATION);

    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_MERGE_TRUNK);

    std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;
    if (!isExistDir(indexDir))
      throw Poco::Exception("Forder: '"+indexDir+"' not exists", ERROR_INDEX_MERGE_TRUNK);

    SphinxFunctionalObject fObject("", fObj.getHomeDir(), indexName);
    if (!fObject.isLoadedConfig())
      throw Poco::Exception(fObject.getErrorMsg(),ERROR_INDEX_MERGE_TRUNK);

    fObject.setLogStream(fObj.log());
    fObj.log() << "fObject.getIndexFileName() = " << fObject.getIndexFileName() << std::endl;

    std::vector<std::string> vIndexes;
    if (!getIndexList(indexDir, vIndexes))
      throw Poco::Exception("Get index list: "+errorMsg, ERROR_INDEX_MERGE_TRUNK);

    if (vIndexes.empty())
      throw Poco::Exception("Empty indexes list", ERROR_INDEX_MERGE);

    const std::string trunkFileName = *(vIndexes.begin());
    // copy trunk index files to index dir
    if (!copyIndexFiles(fObject.getIndexFileName(), path, indexDir))
      throw Poco::Exception("move file: "+errorMsg, ERROR_INDEX_MERGE_TRUNK);

    SphinxConfigOptions configOptions;
    unsigned long long maxDocId = 0;
    unsigned long long branchMaxDocId = 0;

    unsigned int madeFailCount = 0;
    for (size_t k=0;k<branches.size();++k)
      for (size_t i=0;i<vIndexes.size();++i)
        if (vIndexes[i]==branches[k])
        {
          if (!makeMerge(vIndexes[i], path, fObject.getIndexFileName(), branchMaxDocId))
          {
            if (!resultData.empty())
              resultData.append(",");
            resultData.append(vIndexes[i]);
            ++madeFailCount;
          }
          else
          {
            configOptions.addBranch(vIndexes[i]);
            if (maxDocId < branchMaxDocId)
              maxDocId = branchMaxDocId;
          }
          break;
        }

    bool isActive = fObject.isActiveSearchd();   // save state of daemon
    fObject.stopSearchd();

    fObj.log() << "IndexFileName = " << fObj.getIndexFileName() << std::endl;
    fObj.log() << "IS ACTIVE SEARCHD => " << std::boolalpha << isActive << std::endl;


    if (!moveIndexFiles(fObject.getIndexFileName(), indexDir, path))
      throw Poco::Exception("move file: "+errorMsg, ERROR_INDEX_MERGE_TRUNK);

    if (!makeTrunkConfig(fObject.getIndexFileName(), indexName, trunkFileName, configOptions))
      throw Poco::Exception("make config: "+errorMsg, ERROR_INDEX_MERGE_TRUNK);

    fObj.log() << "FO IndexName: " << fObj.getIndexName() << std::endl;
    fObj.log() << "Current IndexName: " << indexName << std::endl;

    if (isActive) // restore source state
      if (!fObject.startSearchd())
        throw Poco::Exception("Index Merge fail. ", ERROR_INDEX_MERGE_TRUNK);

    if (madeFailCount==0)
      _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
    _isError = true;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_INDEX_MERGE_TRUNK;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexDeleteDataFile::IndexDeleteDataFile(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexDeleteDataFile::removeFilesList(const std::string& path, std::vector<std::string>& branches, std::vector<std::string>& files, const std::string& ext) throw (Poco::Exception)
{
  bool result = false;
  unsigned int madeFailCount = 0;
  if (branches.front()=="*")
  {
    for (size_t i=0;i<files.size();++i)
    {
      std::string fileName = path+"/"+files[i]+"."+ext;
      if (!removeFile(fileName))
      {
        if (!resultData.empty())
          resultData.append(",");
        resultData.append(fileName);
        ++madeFailCount;
      }
    }
  }
  else
  {
    for (size_t k=0;k<branches.size();++k)
      for (size_t i=0;i<files.size();++i)
        if (files[i]==branches[k])
        {
          std::string fileName = path+"/"+files[i]+"."+ext;
          if (!removeFile(fileName))
          {
            if (!resultData.empty())
              resultData.append(",");
            resultData.append(fileName);
            ++madeFailCount;
          }
        }
  }
  if (madeFailCount==0)
    result = true;

  return result;
}
//-----------------------------------------------------------------------------
bool IndexDeleteDataFile::removeIndexFiles(const std::string& path, std::vector<std::string>& branches, std::vector<std::string>& files) throw (Poco::Exception)
{
  bool result = false;
  unsigned int madeFailCount = 0;

  if (branches.front()=="*")
  {
    for (size_t i=0;i<files.size();++i)
    {
      if (!removeIndexFile(files[i], path))
      {
        if (!resultData.empty())
          resultData.append(",");
        resultData.append(files[i]);
        ++madeFailCount;
      }
    }
  }
  else
  {
    for (size_t k=0;k<branches.size();++k)
      for (size_t i=0;i<files.size();++i)
        if (files[i]==branches[k])
        {
          if (!removeIndexFile(files[i], path))
          {
            if (!resultData.empty())
              resultData.append(",");
            resultData.append(files[i]);
            ++madeFailCount;
          }
        }
  }
  if (madeFailCount==0)
    result = true;

  return result;
}
//-----------------------------------------------------------------------------
bool IndexDeleteDataFile::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (branches.empty())
      throw Poco::Exception("Received empty list of branches", ERROR_COMMAND_INITIALIZATION);

    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_DELETE_DATA_FILE);

    std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;
    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;
    if (!isExistDir(indexDir))
      throw Poco::Exception("Forder: '"+indexDir+"' not exists", ERROR_INDEX_DELETE_DATA_FILE);

    if (!isExistDir(dataDir))
      throw Poco::Exception("Forder: '"+dataDir+"' not exists", ERROR_INDEX_DELETE_DATA_FILE);

    std::vector<std::string> dataFiles, sourceFiles, configFiles, propertyFiles, indexes;
    if (getFileList(dataDir, dataFiles, sphinx_admin_command_const::dataFileExtension) &&
        getFileList(dataDir, sourceFiles, sphinx_admin_command_const::sourceFileExtension) &&
        getFileList(dataDir, configFiles, sphinx_admin_command_const::branchConfigFileExtention) &&
        getFileList(dataDir, propertyFiles, sphinx_admin_command_const::branchPropertyFileExtention) &&
        getIndexList(indexDir, indexes))
    {
      if (dataFiles.size()==0 && sourceFiles.size()==0 && indexes.size()==0 && configFiles.size()==0 && propertyFiles.size()==0)
      {
        throw Poco::Exception("Data files already deleted", ERROR_INDEX_DELETE_DATA_FILE);
      }
      else
      {
        _isError = !(removeFilesList(dataDir, branches, dataFiles, sphinx_admin_command_const::dataFileExtension) &&
                  removeFilesList(dataDir, branches, sourceFiles, sphinx_admin_command_const::sourceFileExtension) &&
                  removeFilesList(dataDir, branches, configFiles, sphinx_admin_command_const::branchConfigFileExtention) &&
                  removeFilesList(dataDir, branches, propertyFiles, sphinx_admin_command_const::branchPropertyFileExtention) &&
                  removeIndexFiles(indexDir, branches, indexes));
      }
    }
    if (_isError)
      throw Poco::Exception(errorMsg, ERROR_INDEX_DELETE_DATA_FILE);
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexDeleteSchemaFile::IndexDeleteSchemaFile(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexDeleteSchemaFile::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string fileName = fObj.getDataDir()+"/"+indexName+"/"+sphinx_search_const::sphinxSchemaFile;

    if (!removeFile(fileName))
      throw Poco::Exception(errorMsg, ERROR_INDEX_DELETE_SCHEMA_FILE);

    if (isExistFile(fileName))
      throw Poco::Exception("Remove '"+fileName+"' fail", ERROR_INDEX_DELETE_SCHEMA_FILE);

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexAppendDataFile::IndexAppendDataFile(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexAppendDataFile::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_APPEND_DATA_FILE);

    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;
    if (!isExistDir(dataDir))
      throw Poco::Exception("Forder: '"+dataDir+"' not exists", ERROR_INDEX_DELETE_DATA_FILE);

    const std::string dataFileName = dataDir+"/"+branchName+"."+sphinx_admin_command_const::dataFileExtension;
    std::stringstream oldContent;
    SphinxDataFile dataFile;
    std::ifstream ifs(dataFileName.c_str(), std::fstream::binary);
    if (ifs.is_open())
    {
      oldContent << ifs.rdbuf();
      _isError = !dataFile.append(oldContent);
      ifs.close();
      if (_isError)
        throw Poco::Exception(dataFile.getErrorMsg(), ERROR_INDEX_APPEND_DATA_FILE);
    }

    std::stringstream strAppendContent(HCE::decodeBase64(dataContent));
    if (!dataFile.append(strAppendContent))
      throw Poco::Exception(dataFile.getErrorMsg(), ERROR_INDEX_APPEND_DATA_FILE);

    std::fstream fst(dataFileName.c_str(), std::fstream::out|std::fstream::trunc|std::fstream::binary);
    fst << dataFile;
    fst.flush();
    fst.close();

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
IndexDeleteDoc::IndexDeleteDoc(SphinxFunctionalObject& fObj)
:inherited(fObj), ids()
{
}
//-----------------------------------------------------------------------------
void IndexDeleteDoc::addId(unsigned long long id)
{
  ids.push_back(id);
}
//-----------------------------------------------------------------------------
bool IndexDeleteDoc::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexName, indexName);

    Poco::JSON::Array::Ptr array = new Poco::JSON::Array();
    for (size_t i=0;i<ids.size();++i)
      array->add(std::to_string(ids[i]));
    obj->set(sphinx_admin_command_const::documents, array);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexDeleteDoc::unserialize(const std::string& json)
{
  indexName.clear();
  ids.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

    Poco::JSON::Array::Ptr vecDocs = obj->getArray(sphinx_admin_command_const::documents);
    if (!vecDocs.isNull())
    {
      for (size_t k = 0;k<vecDocs->size();++k)
      {
        Poco::Dynamic::Var tmp = vecDocs->get(k);
        if (tmp.isString())
        {
          try
          {
            unsigned long long id = std::stoull(tmp.convert<std::string>());
            ids.push_back(id);
          }
          catch(std::exception& e)
          {
            fObj.log() << "Get bad doc ID: " << e.what() << std::endl;
          }
        }
        if (tmp.isNumeric())
        {
          unsigned long long id = tmp.convert<Poco::Int64>();
          ids.push_back(id);
        }
      }
    }
    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexDeleteDoc::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_DELETE_DOC);

    if (ids.size()==0)
      throw Poco::Exception("Empty append document list", ERROR_INDEX_DELETE_DOC);

    std::string fileName = path+"/"+sphinx_admin_command_const::deletedFileName;
    if (isExistFile(fileName))
    {
      std::fstream fst(fileName.c_str(), std::fstream::out|std::fstream::app);
      if (!fst.is_open())
        throw Poco::Exception("file '"+fileName+"' not opened", ERROR_INDEX_DELETE_DOC);

      for (size_t i=0;i<ids.size();++i)
        fst << (unsigned long long)(ids[i]) << std::endl;
      fst.close();
    }
    else
    {
      std::ofstream ofs(fileName.c_str(), std::fstream::trunc);
      for (size_t i=0;i<ids.size();++i)
        ofs << ids[i] << std::endl;
      ofs.close();
    }
    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexDeleteDocNumber::IndexDeleteDocNumber(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexDeleteDocNumber::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_DELETE_DOC_NUMBER);

    std::string fileName = path+"/"+sphinx_admin_command_const::deletedFileName;
    size_t count = 0;
    if (isExistFile(fileName))
    {
      std::ifstream ifs(fileName.c_str());
      if (!ifs.is_open())
        throw Poco::Exception("file '"+fileName+"' not opened", ERROR_INDEX_DELETE_DOC_NUMBER);

      std::string line;
      while(getline(ifs, line))
      {
        ++count;
      }
      ifs.close();
    }
    resultData = std::to_string(count);
    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_INDEX_DELETE_DOC_NUMBER;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexPackDocData::IndexPackDocData(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexPackDocData::packData(const std::string& file, std::set<std::string>& delList)
{
  bool result = false;
  XMLCleaner xmlCleaner(sphinx_data_source_const::docsetTag,
                        sphinx_data_source_const::documentTag,
                        sphinx_data_source_const::documentIdAttrTag);
  std::string xmlString;
  std::string outString;
  try
  {
    std::ifstream in(file.c_str());
    if (!in.is_open())
      throw Poco::Exception("File "+file+" not opened");

    in.seekg(0, std::ios::end);
    xmlString.resize(in.tellg());
    in.seekg(0, std::ios::beg);
    in.read(&xmlString[0], xmlString.size());
    in.close();

    outString = xmlCleaner.process(xmlString, delList);

    std::ofstream ofs(file.c_str(), std::fstream::trunc);
    ofs << outString;
    ofs.close();

    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = "packData: "+e.displayText();
  }
  return result;
}
//-----------------------------------------------------------------------------
bool IndexPackDocData::getDocumentCount(const std::string& file, size_t& documentCount)
{
  bool result = false;
  try
  {
    std::ifstream ifs(file.c_str());
    if (!ifs.is_open())
      throw Poco::Exception("File '"+file+"' not opened");

    SphinxDataFile dataFile;
    size_t count = dataFile.documentCount(ifs);
    ifs.close();

    if (dataFile.isError())
      throw Poco::Exception(dataFile.getErrorMsg());

    result = true;
    documentCount += count;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = "getDocumentCount: "+e.message();
  }
  return result;
}
//-----------------------------------------------------------------------------
bool IndexPackDocData::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;

  try
  {
    resultData = "0";

    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_PACK_DOC_DATA);

    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;
    if (!isExistDir(dataDir))
      throw Poco::Exception("Forder: '"+dataDir+"' not exists", ERROR_INDEX_PACK_DOC_DATA);

    if (branches.empty())
      throw Poco::Exception("Empty branches list", ERROR_INDEX_PACK_DOC_DATA);

    const std::string backupFile = path+"/"+sphinx_admin_command_const::deletedFileName+".backup";
    const std::string fileName = path+"/"+sphinx_admin_command_const::deletedFileName;
    std::set<std::string> delList;

    if (isExistFile(fileName))
    {
      std::ifstream ifs(fileName.c_str());
      if (!ifs.is_open())
        throw Poco::Exception("file '"+fileName+"' not opened", ERROR_INDEX_PACK_DOC_DATA);

      std::string line;
      while(getline(ifs, line))
      {
        try
        {
          std::stoull(line);
          delList.insert(line);
        }
        catch(std::exception& e)
        {
          fObj.log() << "Bad document ID: " << e.what() << std::endl;
        }
      }
      ifs.close();

      if (!moveFile(fileName, backupFile))
        throw Poco::Exception(errorMsg, ERROR_INDEX_PACK_DOC_DATA);
    }

    std::vector<std::string> vFiles;
    if (!getFileList(dataDir, vFiles, sphinx_admin_command_const::dataFileExtension))
      throw Poco::Exception(errorMsg, errorCode);

    size_t documentCount = 0;

    if (vFiles.size()==0)
    {
      throw Poco::Exception("Empty list of files data", ERROR_INDEX_PACK_DOC_DATA);
    }
    else if (branches.front()=="*")
    {
      for (size_t i=0;i<vFiles.size();++i)
      {
        if (!packData(dataDir+"/"+vFiles[i]+"."+sphinx_admin_command_const::dataFileExtension, delList))
          throw Poco::Exception(errorMsg, ERROR_INDEX_PACK_DOC_DATA);

        if (!getDocumentCount(dataDir+"/"+vFiles[i]+"."+sphinx_admin_command_const::dataFileExtension, documentCount))
          throw Poco::Exception(errorMsg, ERROR_INDEX_PACK_DOC_DATA);
      }
    }
    else
    {
      for (size_t k=0;k<branches.size();++k)
        for (size_t i=0;i<vFiles.size();++i)
          if (vFiles[i]==branches[k])
          {
            if (!packData(dataDir+"/"+vFiles[i]+"."+sphinx_admin_command_const::dataFileExtension, delList))
              throw Poco::Exception(errorMsg, ERROR_INDEX_PACK_DOC_DATA);

            if (!getDocumentCount(dataDir+"/"+vFiles[i]+"."+sphinx_admin_command_const::dataFileExtension, documentCount))
              throw Poco::Exception(errorMsg, ERROR_INDEX_PACK_DOC_DATA);
          }
    }
    if (isExistFile(backupFile))
      if (!removeFile(backupFile))
        throw Poco::Exception(errorMsg, ERROR_INDEX_PACK_DOC_DATA);

    resultData = std::to_string(documentCount);
    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_INDEX_PACK_DOC_DATA;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexRemove::IndexRemove(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexRemove::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exists", ERROR_INDEX_REMOVE);

    SphinxFunctionalObject fObject("", 0, fObj.getHomeDir(), indexName);
    IndexStop indexStop(fObject);
    indexStop.setIndexName(indexName);
    if (!indexStop.execute())
      throw Poco::Exception(indexStop.getErrorMsg(), ERROR_INDEX_REMOVE);

    std::string cmd("rm");
    std::vector<std::string> args = {"-R", path};

    std::stringstream outMsg;
    ProcExec procExec(cmd, args);
    if (!procExec.exec(outMsg, outMsg))
      throw Poco::Exception("Remove '"+path+"' fail", ERROR_INDEX_REMOVE);

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str(), ERROR_INDEX_REMOVE);

    path = fObj.getLogDir()+"/"+indexName;
    if (isExistDir(path))
    {
      args.clear();
      args.push_back("-R");
      args.push_back(path);
      ProcExec procExecLog(cmd, args);
      procExecLog.exec();
    }
    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexCopy::IndexCopy(SphinxFunctionalObject& fObj)
:inherited(fObj), indexFromName(""), indexToName("")
{
}
//-----------------------------------------------------------------------------
bool IndexCopy::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexFromName, indexFromName);
    obj->set(sphinx_admin_command_const::indexToName, indexToName);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexCopy::unserialize(const std::string& json)
{
  indexFromName.clear();
  indexToName.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexFromName);
    if (tmp.isString())
      indexFromName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::indexToName);
    if (tmp.isString())
      indexToName = tmp.convert<std::string>();

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexCopy::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    const std::string srcIndex = fObj.getDataDir()+"/"+indexFromName;
    const std::string dstIndex = fObj.getDataDir()+"/"+indexToName;

    if (isExistDir(dstIndex))
      throw Poco::Exception(indexToName+" already exists", ERROR_INDEX_COPY);

    std::string logDir = fObj.getLogDir()+"/"+indexToName;
    if (!isExistDir(logDir))
      if (!makeDir(logDir))
        throw Poco::Exception("Don't created log dir: '"+logDir+"'", ERROR_INDEX_COPY);

    const std::string cmd("cp");
    std::vector<std::string> args = {"-R", srcIndex, dstIndex};
    ProcExec procExec(cmd, args);
    if (!procExec.exec())
      throw Poco::Exception("Copy '"+srcIndex+"' to '"+dstIndex+"' fail", ERROR_INDEX_COPY);

    const std::string propFile = dstIndex+"/"+sphinx_search_const::sphinxPropertyFile;
    const std::string sphinxConfigFile = dstIndex+"/"+sphinx_search_const::sphinxConfigName;

    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);
    std::vector<std::string> keys;
    pConf->keys(keys);

    for (size_t i=0;i<keys.size();++i)
    {
      if (keys[i].find(sphinx_search_const::sourceNameField)!=std::string::npos)
      {
        std::string name = keys[i]+"."+sphinx_search_const::xmlpipeCommandNameField;
        std::string value = pConf->getString(name);

        size_t pos = value.find(indexFromName);
        if (pos!=std::string::npos)
          value = value.replace(pos, indexFromName.length(), indexToName);

        pConf->setString(name, value);
      }

      if (keys[i].find(sphinx_search_const::indexNameField)!=std::string::npos)
      {
        std::string name = keys[i]+"."+sphinx_search_const::pathNameField;
        std::string value = pConf->getString(name);

        size_t pos = value.find(indexFromName);
        if (pos!=std::string::npos)
          value = value.replace(pos, indexFromName.length(), indexToName);

        pConf->setString(name, value);
      }
    }
    std::string value = fObj.getLogDir()+"/"+indexToName+"/"+sphinx_search_const::searchdLogFile;
    pConf->setString(sphinx_search_const::searchdLogName, value);

    value = fObj.getRunDir()+"/"+/*indexToName+"/"+*/
        sphinx_search_const::searchdPidFileName+"_"+indexToName+"."+
        sphinx_search_const::searchdPidFileExt;
    pConf->setString(sphinx_search_const::searchdPidName, value);

    value = fObj.getLogDir()+"/"+indexToName+"/"+sphinx_search_const::searchdQueryLogFile;
    pConf->setString(sphinx_search_const::searchdQueryLogName, value);

    unsigned int port = 0;
    if (!getFreeAllowedPort(port))
      throw Poco::Exception(errorMsg, ERROR_INDEX_COPY);

    value = fObj.getServerHost()+":"+std::to_string(port);
    pConf->setString(sphinx_search_const::searchdListen, value);

    pConf->save(propFile);
    pConf->setPropertyFileConfiguration(propFile);
    pConf->deleteSphinxConfigSection(sphinx_admin_command_const::sectionOptions);

    std::ofstream ofs(sphinxConfigFile.c_str(), std::fstream::trunc);
    ofs << *pConf;
    ofs.close();

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_INDEX_COPY;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexRename::IndexRename(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexRename::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (!inherited::execute())
      throw Poco::Exception(inherited::getErrorMsg(), ERROR_INDEX_RENAME);

    bool isActive = (fObj.getIndexName()==indexFromName);

    IndexRemove indexRemove(fObj);
    indexRemove.setIndexName(indexFromName);
    if (!indexRemove.execute())
      throw Poco::Exception(indexRemove.getErrorMsg(), ERROR_INDEX_RENAME);

    if (isActive)
      fObj.setIndexName(indexToName);

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexSetConfigVar::IndexSetConfigVar(SphinxFunctionalObject& fObj)
:inherited(fObj), indexName(""), branchName(""), sectionName(""), parameterName(""), parameterValue("")
{
}
//-----------------------------------------------------------------------------
bool IndexSetConfigVar::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexName, indexName);
    obj->set(sphinx_admin_command_const::branchName, branchName);
    obj->set(sphinx_admin_command_const::sectionName, sectionName);
    obj->set(sphinx_admin_command_const::parameterName, parameterName);
    obj->set(sphinx_admin_command_const::parameterValue, parameterValue);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexSetConfigVar::unserialize(const std::string& json)
{
  indexName.clear();
  sectionName.clear();
  parameterName.clear();
  parameterValue.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::branchName);
    if (tmp.isString())
      branchName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::sectionName);
    if (tmp.isString())
      sectionName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::parameterName);
    if (tmp.isString())
      parameterName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::parameterValue);
    if (tmp.isString())
      parameterValue = tmp.convert<std::string>();

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexSetConfigVar::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists");

    const std::string configFile = (branchName.empty())?(path+"/"+sphinx_search_const::sphinxConfigName):(getConfigFileName(path, branchName));
    const std::string propFile = (branchName.empty())?(path+"/"+sphinx_search_const::sphinxPropertyFile):(getPropertyFileName(path, branchName));

    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);

    const std::string name = sectionName+"."+parameterName;
    pConf->setString(name, parameterValue);
    pConf->save(propFile);
    pConf->setPropertyFileConfiguration(propFile);
    pConf->deleteSphinxConfigSection(sphinx_admin_command_const::sectionOptions);

    std::ofstream ofs(configFile.c_str(), std::fstream::trunc);
    ofs << *pConf;
    ofs.close();

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_SET_CONFIG_VAR;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexGetConfigVar::IndexGetConfigVar(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexGetConfigVar::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(sphinx_admin_command_const::indexName, indexName);
    obj->set(sphinx_admin_command_const::sectionName, sectionName);
    obj->set(sphinx_admin_command_const::parameterName, parameterName);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexGetConfigVar::unserialize(const std::string& json)
{
  indexName.clear();
  sectionName.clear();
  parameterName.clear();
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(sphinx_admin_command_const::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::sectionName);
    if (tmp.isString())
      sectionName = tmp.convert<std::string>();

    tmp = obj->get(sphinx_admin_command_const::parameterName);
    if (tmp.isString())
      parameterName = tmp.convert<std::string>();

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexGetConfigVar::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists");

    const std::string propFile = (branchName.empty())?(path+"/"+sphinx_search_const::sphinxPropertyFile):(getPropertyFileName(path, branchName));

    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);

    const std::string name = sectionName+"."+parameterName;
    resultData = pConf->getString(name);

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_GET_CONFIG_VAR;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexCheckSchema::IndexCheckSchema(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexCheckSchema::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_CHECK_SCHEMA);

    path.append("/").append(sphinx_search_const::sphinxSchemaFile);
    std::ifstream ifs(path.c_str(), std::fstream::binary);
    if (!ifs.is_open())
      throw Poco::Exception("File '"+path+"' not found" , ERROR_INDEX_CHECK_SCHEMA);

    SphinxSchemaFile oldSchemaFile(ifs);
    std::vector<std::pair<std::string, int> > oldSchemaVec;
    bool ret = oldSchemaFile.getFields(oldSchemaVec);  // need for read all attributes
    ifs.close();
    if (!ret)
      throw Poco::Exception(oldSchemaFile.getErrorMsg(), ERROR_INDEX_CHECK_SCHEMA);

    std::stringstream str;
    str << HCE::decodeBase64(schemaContent);

    std::vector<std::pair<std::string, int> > checkSchemaVec;
    SphinxSchemaFile checkSchemaFile(str);
    if (!checkSchemaFile.getFields(checkSchemaVec))  // need for read all attributes
      throw Poco::Exception(checkSchemaFile.getErrorMsg(), ERROR_INDEX_CHECK_SCHEMA);

    for (size_t i=0;i<checkSchemaVec.size();++i)
    {
      bool isFound = false;
      for (size_t k=0;k<oldSchemaVec.size();++k)
      {
        if (checkSchemaVec[i].first==oldSchemaVec[k].first)
        {
          isFound = true;
          break;
        }
      }
      if (!isFound)
        throw Poco::Exception("Invalid schema. Field '"+checkSchemaVec[i].first+"' not found", ERROR_INDEX_CHECK_SCHEMA);
    }

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.displayText();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexStatusSearchd::IndexStatusSearchd(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexStatusSearchd::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;

  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_SEARCHD_STATUS);

    const std::string configFile = path+"/"+sphinx_search_const::sphinxConfigName;
    if (!isExistFile(configFile))
      throw Poco::Exception("Config file '"+configFile+"' not exist", ERROR_INDEX_SEARCHD_STATUS);

    std::stringstream outMsg, errMsg;
    const std::string cmd("searchd");
    std::vector<std::string> args = {"--status", "--config", configFile};
    ProcExec procExec(cmd, args);
    if (!procExec.exec(outMsg, errMsg))
      throw Poco::Exception("Get status searchd '"+configFile+"' fail\n"+errMsg.str(), ERROR_INDEX_SEARCHD_STATUS);

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str(), ERROR_INDEX_SEARCHD_STATUS);

    resultData = outMsg.str();

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexStatusSearchd::isExistPidFile(void)
{
  bool result = false;

  try
  {
    const std::string propFile = fObj.getDataDir()+"/"+indexName+"/"+sphinx_search_const::sphinxPropertyFile;
    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);
    const std::string pidFile = pConf->getString(sphinx_search_const::searchdPidName);
    result = isExistFile(pidFile);
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_INDEX_STATUS;
  }
  return result;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexStatus::IndexStatus(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexStatus::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;

  try
  {
    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_STATUS);

    const std::string configFile = path+"/"+sphinx_search_const::sphinxConfigName;
    if (!isExistFile(configFile))
      throw Poco::Exception("Config file '"+configFile+"' not exist", ERROR_INDEX_STATUS);

    std::stringstream outMsg;
    const std::string cmd("indextool");
    std::vector<std::string> args = {"--dumpheader", fObj.getIndexFileName(), "--config", configFile};
    ProcExec procExec(cmd, args);
    outMsg << procExec;
    if (procExec.isError())
      throw Poco::Exception("Get index status '"+configFile+"' fail", ERROR_INDEX_STATUS);

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str(), ERROR_INDEX_STATUS);

    resultData = outMsg.str();

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexMaxDocId::IndexMaxDocId(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexMaxDocId::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;

  try
  {
    unsigned long long maxDocId = 0;
    resultData = std::to_string(maxDocId);

    std::string path = fObj.getDataDir()+"/"+indexName;
    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_MAX_DOC_ID);

    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;

    if (!isExistDir(dataDir))
      throw Poco::Exception("Forder: '"+dataDir+"' not exists", ERROR_INDEX_MAX_DOC_ID);

    std::vector<std::string> vFiles;
    if (!getFileList(dataDir, vFiles, sphinx_admin_command_const::sourceFileExtension))
      throw Poco::Exception(errorMsg, ERROR_INDEX_MAX_DOC_ID);

    std::ifstream ifs;
    SphinxDataSourceParameters dataSourceParameters;
    for (size_t i=0;i<vFiles.size();++i)
    {
      const std::string fileName = dataDir+"/"+vFiles[i] +"."+sphinx_admin_command_const::sourceFileExtension;
      ifs.open(fileName.c_str());
      if (ifs.is_open())
      {
        if (dataSourceParameters.load(ifs))
        {
          if (maxDocId < dataSourceParameters.getMaxDocId())
            maxDocId = dataSourceParameters.getMaxDocId();
        }
        else
          fObj.log() << "Search MaxDocsID in '" << fileName << "' fail." << dataSourceParameters.getErrorMsg() << std::endl;
        ifs.close();
      }
      else
        fObj.log() << "File '" << fileName << "' not open" << std::endl;
    }

    resultData = std::to_string(maxDocId);
    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_INDEX_MAX_DOC_ID;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexDataList::IndexDataList(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexDataList::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (indexName.empty())
      indexName = fObj.getIndexName();

    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_DATA_LIST);

    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;

    if (!isExistDir(path+"/"+sphinx_admin_command_const::dataDir))
      throw Poco::Exception("Forder: '"+path+"/"+sphinx_admin_command_const::dataDir+"' not exists", ERROR_INDEX_DATA_LIST);

    std::vector<std::string> vFiles;
    if (getFileList(dataDir, vFiles, sphinx_admin_command_const::dataFileExtension))
    {
      for (size_t i=0;i<vFiles.size();++i)
      {
        if (!resultData.empty())
          resultData.append(",");
        resultData.append(vFiles[i]);
      }
      _isError = false;
    }
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexBranchesList::IndexBranchesList(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexBranchesList::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (indexName.empty())
      indexName = fObj.getIndexName();

    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_BRANCHES_LIST);

    std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;

    if (!isExistDir(path+"/"+sphinx_admin_command_const::indexDir))
      throw Poco::Exception("Forder: '"+path+"/"+sphinx_admin_command_const::indexDir+"' not exists", ERROR_INDEX_BRANCHES_LIST);

    std::vector<std::string> vIndexes;
    if (getIndexList(indexDir, vIndexes))
    {
      for (size_t i=0;i<vIndexes.size();++i)
      {
        if (!resultData.empty())
          resultData.append(",");
        resultData.append(vIndexes[i]);
      }
      _isError = false;
    }
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexBranchesInfo::IndexBranchesInfo(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexBranchesInfo::getBranchInfo(const std::string& branchName, const std::string& branchPath, std::string& branchFieldsList)
{
  bool result = false;
  branchFieldsList.clear();
  const std::string branchFileName = branchPath+"/"+branchName+"."+sphinx_admin_command_const::sourceFileExtension;

  try
  {
    std::ifstream ifs;
    SphinxDataSourceParameters dataSourceParameters;
    ifs.open(branchFileName.c_str());
    if (!ifs.is_open())
      throw Poco::Exception("Open "+branchFileName+" fail");

    bool loaded = dataSourceParameters.load(ifs);
    ifs.close();
    if (!loaded)
      throw Poco::Exception("Load "+branchFileName+" fail. "+dataSourceParameters.getErrorMsg());

    std::string fieldsList;
    SphinxDataSourceParameters::PARAM_ATTR__MAP& paramAttr = dataSourceParameters.getParamAttr();
    for (SphinxDataSourceParameters::PARAM_ATTR__MAP::iterator iter=paramAttr.begin();iter!=paramAttr.end();++iter)
    {
      if (!fieldsList.empty())
        fieldsList.append(",");
      fieldsList.append((*iter).first).append("=").append(std::to_string((*iter).second));
    }
    Poco::URI::encode(fieldsList, "", branchFieldsList);
    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
  }
  return result;
}
//-----------------------------------------------------------------------------
bool IndexBranchesInfo::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (branches.empty())
      throw Poco::Exception("Received empty list of branches", ERROR_COMMAND_INITIALIZATION);

    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_BRANCHES_INFO);

    const std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;
    const std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;

    if (!isExistDir(indexDir))
      throw Poco::Exception("Forder: '"+indexDir+"' not exists", ERROR_INDEX_BRANCHES_INFO);

    if (!isExistDir(dataDir))
      throw Poco::Exception("Forder: '"+dataDir+"' not exists", ERROR_INDEX_BRANCHES_INFO);

    std::vector<std::string> vFiles;
    if (getFileList(dataDir, vFiles, sphinx_admin_command_const::sourceFileExtension))
    {
      unsigned int madeFailCount = 0;
      if (branches.front()=="*")
      {
        for (size_t i=0;i<vFiles.size();++i)
        {
          std::string branchFieldsList;
          if (getBranchInfo(vFiles[i], dataDir, branchFieldsList))
          {
            if (!resultData.empty())
              resultData.append("&");
            resultData.append(vFiles[i]).append("=").append(branchFieldsList);
          }
          else
            ++madeFailCount;
        }
      }
      else
      {
        for (size_t k=0;k<branches.size();++k)
          for (size_t i=0;i<vFiles.size();++i)
            if (vFiles[i]==branches[k])
            {
              std::string branchFieldsList;
              if (getBranchInfo(vFiles[i], dataDir, branchFieldsList))
              {
                if (!resultData.empty())
                  resultData.append("&");
                resultData.append(vFiles[i]).append("=").append(branchFieldsList);
              }
              else
                ++madeFailCount;
              break;
            }
      }
      if (madeFailCount==0)
        _isError = false;
    }

    if (_isError)
      throw Poco::Exception(errorMsg, ERROR_INDEX_BRANCHES_INFO);
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexBranchesStatus::IndexBranchesStatus(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexBranchesStatus::makeBranchConfig(const std::string& indexName, const std::string& indexFileName, std::string& configFile)
{
  bool result = false;
  const std::string path = fObj.getDataDir()+"/"+indexName;
  const std::string propFile = path+"/"+sphinx_search_const::sphinxPropertyFile;
  configFile = path+"/"+sphinx_search_const::branchConfigFile;
  try
  {
    Poco::AutoPtr<SphinxConfigCreator> pConf = new SphinxConfigCreator(propFile);
    std::vector<std::string> keys;
    pConf->keys(keys);

    std::string trunkSectionName;
    for (size_t i=0;i<keys.size();++i)
    {
      if (keys[i].find(sphinx_search_const::sourceNameField)!=std::string::npos)
      {
        std::string name = keys[i]+"."+sphinx_search_const::xmlpipeCommandNameField;
        std::string value = "cat "+path+"/"+sphinx_admin_command_const::dataDir+"/"+indexFileName+"."+sphinx_admin_command_const::sourceFileExtension;
        pConf->setString(name, value);
      }
      if (keys[i].find(sphinx_search_const::indexNameField)!=std::string::npos)
        trunkSectionName = keys[i];
    }
    std::string name = sphinx_search_const::indexNameField+" "+fObj.getIndexFileName()+"."+sphinx_search_const::pathNameField;
    std::string value = path+"/"+fObj.getIndexFileName();
    pConf->setString(name, value);

    std::string branchSectionName = sphinx_search_const::indexNameField+" "+indexFileName;
    pConf->cloneSphinxConfigSection(trunkSectionName, branchSectionName);

    name = branchSectionName+"."+sphinx_search_const::pathNameField;
    value = path+"/"+sphinx_admin_command_const::indexDir+"/"+indexFileName;
    pConf->setString(name, value);

    value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdLogFile;
    pConf->setString(sphinx_search_const::searchdLogName, value);

    value = fObj.getRunDir()+"/"+/*indexName+"/"+*/
        sphinx_search_const::searchdPidFileName+"_"+indexName+"."+
        sphinx_search_const::searchdPidFileExt;
    pConf->setString(sphinx_search_const::searchdPidName, value);

    value = fObj.getLogDir()+"/"+indexName+"/"+sphinx_search_const::searchdQueryLogFile;
    pConf->setString(sphinx_search_const::searchdQueryLogName, value);

    pConf->save(propFile);
    pConf->setPropertyFileConfiguration(propFile);
    pConf->deleteSphinxConfigSection(sphinx_admin_command_const::sectionOptions);

    std::ofstream ofs(configFile.c_str(), std::fstream::trunc);
    ofs << *pConf;
    ofs.close();
    result = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    fObj.log() << "Make branch config error: " << errorMsg << std::endl;
  }
  return result;


}
//-----------------------------------------------------------------------------
bool IndexBranchesStatus::getBranchInfo(const std::string& indexName, const std::string& indexFileName, std::string& information)
{
  bool result = false;
  information.clear();

  try
  {
    std::string branchConfigFileName;
    if (!makeBranchConfig(indexName, indexFileName, branchConfigFileName))
      throw Poco::Exception(errorMsg, ERROR_INDEX_STATUS);

    if (!isExistFile(branchConfigFileName))
      throw Poco::Exception("Config file '"+branchConfigFileName+"' not exist", ERROR_INDEX_STATUS);

    std::stringstream outMsg, errMsg;
    const std::string cmd("indextool");
    std::vector<std::string> args = {"--dumpheader", indexFileName, "--config", branchConfigFileName};
    ProcExec procExec(cmd, args);
    if (!procExec.exec(outMsg, errMsg))
      throw Poco::Exception("Get status '"+indexFileName+"' fail\n"+errMsg.str(), ERROR_INDEX_STATUS);

    if (isExistError(outMsg.str()))
      throw Poco::Exception(outMsg.str(), ERROR_INDEX_STATUS);

    Poco::URI::encode(outMsg.str(), "", information);

    result = removeFile(branchConfigFileName);
  }
  catch(Poco::Exception& e)
  {
    errorMsg.append(e.message());
    errorCode = e.code();
  }
  return result;
}
//-----------------------------------------------------------------------------
bool IndexBranchesStatus::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;
  try
  {
    if (branches.empty())
      throw Poco::Exception("Received empty list of branches", ERROR_COMMAND_INITIALIZATION);

    std::string path = fObj.getDataDir()+"/"+indexName;

    if (!isExistDir(path))
      throw Poco::Exception("Forder: '"+path+"' not exists", ERROR_INDEX_BRANCHES_STATUS);

    std::string indexDir = path+"/"+sphinx_admin_command_const::indexDir;
    std::string dataDir = path+"/"+sphinx_admin_command_const::dataDir;

    if (!isExistDir(indexDir))
      throw Poco::Exception("Forder: '"+indexDir+"' not exists", ERROR_INDEX_BRANCHES_STATUS);

    if (!isExistDir(dataDir))
      throw Poco::Exception("Forder: '"+dataDir+"' not exists", ERROR_INDEX_BRANCHES_STATUS);

    std::vector<std::string> vIndexes;
    if (getIndexList(indexDir, vIndexes))
    {
      unsigned int madeFailCount = 0;
      if (branches.front()=="*")
      {
        for (size_t i=0;i<vIndexes.size();++i)
        {
          std::string information;
          if (getBranchInfo(indexName, vIndexes[i], information))
          {
            if (!resultData.empty())
              resultData.append("&");
            resultData.append(vIndexes[i]).append("=").append(information);
          }
          else
            ++madeFailCount;
        }
      }
      else
      {
        for (size_t k=0;k<branches.size();++k)
          for (size_t i=0;i<vIndexes.size();++i)
            if (vIndexes[i]==branches[k])
            {
              std::string information;
              if (getBranchInfo(indexName, vIndexes[i], information))
              {
                if (!resultData.empty())
                  resultData.append("&");
                resultData.append(vIndexes[i]).append("=").append(information);
              }
              else
                ++madeFailCount;
              break;
            }
      }
      if (madeFailCount==0)
        _isError = false;
    }

    if (_isError)
      throw Poco::Exception(errorMsg, ERROR_INDEX_BRANCHES_STATUS);
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
IndexConnect::IndexConnect(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexConnect::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;

  try
  {
    if (indexName.empty() && fObj.getIndexName().empty())
      throw Poco::Exception("Current index name is empty", ERROR_INDEX_CONNECT);

    std::string path = (indexName.empty())?(fObj.getDataDir()+"/"+fObj.getIndexName()):(fObj.getDataDir()+"/"+indexName);

    if (!isExistDir(path))
      throw Poco::Exception("Index '"+path+"' not exist", ERROR_INDEX_CONNECT);

    path.append("/").append(sphinx_search_const::sphinxConfigName);
    if (!isExistFile(path))
      throw Poco::Exception("Config file '"+path+"' not exist", ERROR_INDEX_CONNECT);

    if (!indexName.empty())
      fObj.setIndexName(indexName);

    if (!fObj.loadConfiguration(fObj.getIndexName()))
      throw Poco::Exception(fObj.getErrorMsg(), ERROR_INDEX_CONNECT);

    if (fObj.isConnected())
      if (!fObj.close())
        throw Poco::Exception(fObj.getErrorMsg(), ERROR_INDEX_CONNECT);

    if (!fObj.easyStart())
      throw Poco::Exception(fObj.getErrorMsg(), ERROR_INDEX_CONNECT);

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IndexDisconnect::IndexDisconnect(SphinxFunctionalObject& fObj)
:inherited(fObj)
{
}
//-----------------------------------------------------------------------------
bool IndexDisconnect::serialize(std::string& json)
{
  _isError = true;
  errorMsg.clear();
  try
  {
   Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();

   std::stringstream ostr;
   Poco::JSON::Stringifier::stringify(obj, ostr);
   json = ostr.str();

   _isError = false;
  }
  catch(std::exception& e)
  {
   errorMsg = e.what();
   errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexDisconnect::unserialize(const std::string& json)
{
  errorMsg.clear();
  _isError = true;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool IndexDisconnect::execute(void)
{
  errorMsg.clear();
  errorCode = NO_ERROR;
  _isError = true;

  try
  {
    if (fObj.isConnected())
      if (!fObj.close())
        throw Poco::Exception(fObj.getErrorMsg(), ERROR_INDEX_DISCONNECT);

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = e.code();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace sphinx
} // end namespace HCE