SphinxAdminCommand.hpp

Go to the documentation of this file.

#ifndef SPHINX_ADMIN_COMMAND_HPP
#define SPHINX_ADMIN_COMMAND_HPP

#include <Poco/SharedPtr.h>

#include "JsonSerializable.hpp"
#include "SphinxFunctionalObject.hpp"
#include "CustomMessage.hpp"

namespace HCE
{
namespace sphinx
{
namespace sphinx_admin_command_const
{
  const std::string indexDir = "index";
  const std::string dataDir = "data";

  const std::string dataFileExtension = "dat";
  const std::string sourceFileExtension = "xml";
  const std::string branchConfigFileExtention = "cfg";
  const std::string branchPropertyFileExtention = "property";
  const std::string deletedFileName = "list.deleted";

  const std::string indexName = "index";
  const std::string branchName = "branch";
  const std::string dataContent = "data";
  const std::string branches = "branches";
  const std::string documents = "documents";
  const std::string indexFromName = "index_from";
  const std::string indexToName = "index_to";
  const std::string sectionName = "section_name";
  const std::string parameterName = "parameter_name";
  const std::string parameterValue = "parameter_value";
  const std::string allowedSimbols = "*0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-";
  const std::string procExecErrorMsg = "ERROR:";
  const std::string procExecFatalMsg = "FATAL:";

  const std::string sectionOptions = "options";
  const std::string optionsMaxDocId = sectionOptions+".max_doc_id";
  const std::string optionsCreatedDate = sectionOptions+".cdate";
  const std::string optionsMergedDate = sectionOptions+".mdate";
  const std::string optionsBranches = sectionOptions+".branches";
  const std::string optionsRanker = sectionOptions+".ranker";
  const std::string optionsRankerExpression = sectionOptions+".ranker_expression";
}
class SphinxConfigCreator;
class SphinxConfigOptions;
//-----------------------------------------------------------------------------
class SphinxAdminCommand : public IJsonSerializable
{
public:
  explicit SphinxAdminCommand(SphinxFunctionalObject& fObj_);
  virtual ~SphinxAdminCommand(void) {};

  void setResultData(const std::string& resultData_) {resultData=resultData_;}
  std::string getResultData(void) const {return resultData;}

  virtual bool execute(void)=0;
protected:
  bool makeDir(const std::string& path);
  bool cleanDir(const std::string& path);
  bool isExistDir(const std::string& path);
  bool isExistFile(const std::string& file);
  bool isAllowedString(const std::string& str);
  bool copyFile(const std::string& srcFile, const std::string& dstFile);
  bool moveFile(const std::string& srcFile, const std::string& dstFile);
  bool removeFile(const std::string& file);
  bool moveIndexFiles(const std::string& indexFileName, const std::string& srcPath, const std::string& dstPath);
  bool copyIndexFiles(const std::string& indexFileName, const std::string& srcPath, const std::string& dstPath);
  bool removeIndexFile(const std::string& indexFileName, const std::string& path);
  bool getFileList(const std::string& path, std::vector<std::string>& vFiles, const std::string& ext);
  bool getIndexList(const std::string& path, std::vector<std::string>& vIndexes);
  bool getFreeAllowedPort(unsigned int& res);
  bool makeTrunkConfig(const std::string& trunkName, const std::string& indexName, const std::string& indexFileName,
      SphinxConfigOptions& configOptions);

  bool isExistError(const std::string& shellExecMsg);

  std::string getPropertyFileName(const std::string& indexPath, const std::string& branchName);
  std::string getConfigFileName(const std::string& indexPath, const std::string& branchName);

  void writePropertyOptions(SphinxConfigCreator& configCreator, const SphinxConfigOptions& configOptions);

  SphinxFunctionalObject& fObj;
  std::string resultData;

  CustomMessage& message;

  typedef IJsonSerializable inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class SphinxAdminCommandFactory
{
public:
  Poco::SharedPtr<SphinxAdminCommand> create(SphinxFunctionalObject& fObj, const std::string& commandString);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexCreate : public SphinxAdminCommand
{
public:
  explicit IndexCreate(SphinxFunctionalObject& fObj);
  virtual ~IndexCreate(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  virtual bool execute(void);

  void setIndexName(const std::string& indexName_) {indexName=indexName_;}
  std::string getIndexName(void) const {return indexName;}
protected:
  std::string indexName;

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexCheck : public IndexCreate
{
public:
  explicit IndexCheck(SphinxFunctionalObject& fObj);
  virtual ~IndexCheck(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexStoreDataFile : public SphinxAdminCommand
{
public:
  explicit IndexStoreDataFile(SphinxFunctionalObject& fObj);
  virtual ~IndexStoreDataFile(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  void setIndexName(const std::string& indexName_) {indexName=indexName_;}
  std::string getIndexName(void) const {return indexName;}

  void setBranchName(const std::string& branchName_) {branchName=branchName_;}
  std::string getBranchName(void) const {return branchName;}

  void setDataContent(const std::string& dataContent_) {dataContent=dataContent_;}
  std::string getDataContent(void) const {return dataContent;}

protected:
  std::string indexName;
  std::string branchName;
  std::string dataContent;

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexStoreSchemaFile : public SphinxAdminCommand
{
public:
  explicit IndexStoreSchemaFile(SphinxFunctionalObject& fObj);
  virtual ~IndexStoreSchemaFile(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  void setIndexName(const std::string& indexName_) {indexName=indexName_;}
  std::string getIndexName(void) const {return indexName;}

  void setSchemaContent(const std::string& schemaContent_) {schemaContent=schemaContent_;}
  std::string getSchemaContent(void) const {return schemaContent;}

protected:
  std::string indexName;
  std::string schemaContent;

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
class IndexRebuild : public SphinxAdminCommand
{
protected:
  bool makeSource(const std::string& schemaFile, const std::string& branchName, const std::string& sourcePath, const std::string& configPath);
  bool makeIndex(const std::string& sourceFile, const std::string& branchName, const std::string& configPath, unsigned long long maxDocId);
public:
  explicit IndexRebuild(SphinxFunctionalObject& fObj);
  virtual ~IndexRebuild(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  void setIndexName(const std::string& indexName_) {indexName=indexName_;}
  std::string getIndexName(void) const {return indexName;}

  void addBranch(const std::string& branch) {branches.push_back(branch);}
  std::vector<std::string>& getBranches(void) {return branches;}

protected:
  std::string indexName;
  std::vector<std::string> branches;

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexSetDataDir : public SphinxAdminCommand       //TODO
{
public:
  explicit IndexSetDataDir(SphinxFunctionalObject& fObj);
  virtual ~IndexSetDataDir(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexStart : public IndexCreate
{
public:
  explicit IndexStart(SphinxFunctionalObject& fObj);
  virtual ~IndexStart(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexStop : public IndexCreate
{
public:
  explicit IndexStop(SphinxFunctionalObject& fObj);
  virtual ~IndexStop(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexMerge : public IndexRebuild
{
protected:
  bool makeMerge(const std::string& branchName,
      const std::string& configPath,
      const std::string& trunkName,
      unsigned long long& maxDocId);
  bool makeTrunk(const std::string& trunkName,
      const std::string& configPath,
      std::vector<std::string>& vIndexes,
      unsigned long long& maxDocId) throw (Poco::Exception);
public:
  explicit IndexMerge(SphinxFunctionalObject& fObj);
  virtual ~IndexMerge(void) {};

  bool execute(void);

  typedef IndexRebuild inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexMergeTrunk : public IndexMerge
{
public:
  explicit IndexMergeTrunk(SphinxFunctionalObject& fObj);
  virtual ~IndexMergeTrunk(void) {};

  bool execute(void);

  typedef IndexMerge inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexDeleteDataFile : public IndexMerge
{
  bool removeIndexFiles(const std::string& path, std::vector<std::string>& branches, std::vector<std::string>& files) throw (Poco::Exception);
  bool removeFilesList(const std::string& path, std::vector<std::string>& branches, std::vector<std::string>& files, const std::string& ext) throw (Poco::Exception);
public:
  explicit IndexDeleteDataFile(SphinxFunctionalObject& fObj);
  virtual ~IndexDeleteDataFile(void) {};

  bool execute(void);

  typedef IndexMerge inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexDeleteSchemaFile : public IndexCreate
{
public:
  explicit IndexDeleteSchemaFile(SphinxFunctionalObject& fObj);
  virtual ~IndexDeleteSchemaFile(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexAppendDataFile : public IndexStoreDataFile
{
public:
  explicit IndexAppendDataFile(SphinxFunctionalObject& fObj);
  virtual ~IndexAppendDataFile(void) {};

  bool execute(void);

  typedef IndexStoreDataFile inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexDeleteDoc : public IndexCreate
{
public:
  explicit IndexDeleteDoc(SphinxFunctionalObject& fObj);
  virtual ~IndexDeleteDoc(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  void addId(unsigned long long id);
  std::vector <unsigned long long>& getIds(void) {return ids;}
private:
  std::vector <unsigned long long> ids;
  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexDeleteDocNumber : public IndexCreate
{
public:
  explicit IndexDeleteDocNumber(SphinxFunctionalObject& fObj);
  virtual ~IndexDeleteDocNumber(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexPackDocData : public IndexRebuild
{
  bool packData(const std::string& file, std::set<std::string>& delList);
  bool getDocumentCount(const std::string& file, size_t& documentCount);
public:
  explicit IndexPackDocData(SphinxFunctionalObject& fObj);
  virtual ~IndexPackDocData(void) {};

  bool execute(void);

  typedef IndexRebuild inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexRemove : public IndexCreate
{
public:
  explicit IndexRemove(SphinxFunctionalObject& fObj);
  virtual ~IndexRemove(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexCopy : public SphinxAdminCommand
{
public:
  explicit IndexCopy(SphinxFunctionalObject& fObj);
  virtual ~IndexCopy(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  void setIndexFromName(const std::string& indexFromName_) {indexFromName=indexFromName_;}
  std::string getIndexFromName(void) const {return indexFromName;}

  void setIndexToName(const std::string& indexToName_) {indexToName=indexToName_;}
  std::string getIndexToName(void) const {return indexToName;}

protected:
  std::string indexFromName;
  std::string indexToName;

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexRename : public IndexCopy
{
public:
  explicit IndexRename(SphinxFunctionalObject& fObj);
  virtual ~IndexRename(void) {};

  bool execute(void);

  typedef IndexCopy inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexSetConfigVar : public SphinxAdminCommand
{
public:
  explicit IndexSetConfigVar(SphinxFunctionalObject& fObj);
  virtual ~IndexSetConfigVar(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  void setIndexName(const std::string& indexName_) {indexName=indexName_;}
  std::string getIndexName(void) const {return indexName;}

  void setBranchName(const std::string& branchName_) {branchName=branchName_;}
  std::string getBranchName(void) const {return branchName;}

  void setSectionName(const std::string& sectionName_) {sectionName=sectionName_;}
  std::string getSectionName(void) const {return sectionName;}

  void setParameterName(const std::string& parameterName_) {parameterName=parameterName_;}
  std::string getParameterName(void) const {return parameterName;}

  void setParameterValue(const std::string& parameterValue_) {parameterValue=parameterValue_;}
  std::string getParameterValue(void) const {return parameterValue;}

protected:
  std::string indexName;
  std::string branchName;
  std::string sectionName;
  std::string parameterName;
private:
  std::string parameterValue;

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexGetConfigVar : public IndexSetConfigVar
{
public:
  explicit IndexGetConfigVar(SphinxFunctionalObject& fObj);
  virtual ~IndexGetConfigVar(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  typedef IndexSetConfigVar inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexCheckSchema : public IndexStoreSchemaFile
{
public:
  explicit IndexCheckSchema(SphinxFunctionalObject& fObj);
  virtual ~IndexCheckSchema(void) {};

  bool execute(void);

  typedef IndexStoreSchemaFile inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexStatusSearchd : public IndexCreate
{
public:
  explicit IndexStatusSearchd(SphinxFunctionalObject& fObj);
  virtual ~IndexStatusSearchd(void) {};

  bool execute(void);
  bool isExistPidFile(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexStatus : public IndexCreate
{
public:
  explicit IndexStatus(SphinxFunctionalObject& fObj);
  virtual ~IndexStatus(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexMaxDocId : public IndexCreate
{
public:
  explicit IndexMaxDocId(SphinxFunctionalObject& fObj);
  virtual ~IndexMaxDocId(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexDataList : public IndexCreate
{
public:
  explicit IndexDataList(SphinxFunctionalObject& fObj);
  virtual ~IndexDataList(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexBranchesList : public IndexCreate
{
public:
  explicit IndexBranchesList(SphinxFunctionalObject& fObj);
  virtual ~IndexBranchesList(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexBranchesInfo : public IndexRebuild
{
public:
  explicit IndexBranchesInfo(SphinxFunctionalObject& fObj);
  virtual ~IndexBranchesInfo(void) {};

  bool execute(void);
protected:
  bool getBranchInfo(const std::string& branchName, const std::string& path, std::string& branchFieldsList);

  typedef IndexRebuild inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexBranchesStatus : public IndexRebuild
{
public:
  explicit IndexBranchesStatus(SphinxFunctionalObject& fObj);
  virtual ~IndexBranchesStatus(void) {};

  bool execute(void);
protected:
  bool getBranchInfo(const std::string& indexName, const std::string& indexFileName, std::string& information);
  bool makeBranchConfig(const std::string& indexName, const std::string& indexFileName, std::string& branchConfigFileName);

  typedef IndexRebuild inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexConnect : public IndexCreate
{
public:
  explicit IndexConnect(SphinxFunctionalObject& fObj);
  virtual ~IndexConnect(void) {};

  bool execute(void);

  typedef IndexCreate inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class IndexDisconnect : public SphinxAdminCommand
{
public:
  explicit IndexDisconnect(SphinxFunctionalObject& fObj);
  virtual ~IndexDisconnect(void) {};

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);
  bool execute(void);

  typedef SphinxAdminCommand inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace sphinx
} // end namespace HCE

#endif // SPHINX_ADMIN_COMMAND_HPP