Crest::CrestFsClient Class Reference

#include <CrestApiFs.h>

Inheritance diagram for Crest::CrestFsClient:

Collaboration diagram for Crest::CrestFsClient:

Public Member Functions
	CrestFsClient (bool rewriteIfExists, const std::string &root_folder)
	CrestFsClient constructor. More...
	~CrestFsClient ()
	CrestClient destructor. More...
void	createGlobalTag (GlobalTagDto &globalTag) override
	This method creates a global tag on the file storage. More...
GlobalTagDto	findGlobalTag (const std::string &name) override
	This method finds a global tag by name on the file storage. More...
GlobalTagSetDto	listGlobalTags (const std::string &name, int size, int page, const std::string &sort) override
	This method finds the global tags on the file storage. More...
void	removeGlobalTag (const std::string &name) override
	This method removes a global tag. More...
void	createTag (TagDto &tag) override
	This method creates a tag on the file storage. More...
TagDto	findTag (const std::string &name) override
	This method finds a tag by the name on the file storage. More...
TagSetDto	listTags (const std::string &name, int size, int page, const std::string &sort) override
	This method returns the tag list as TagSetDto. More...
void	removeTag (const std::string &name) override
	This method removes a tag from the file storage. More...
int	getSize (const std::string &tagname) override
	This method gets the number of IOVs for the given tag. More...
void	createTagMeta (TagMetaDto &tag) override
	This method creates a tag meta info on the file storage. More...
void	updateTagMeta (TagMetaDto &tag) override
	This method updates a tag meta info on the file storage. More...
TagMetaDto	findTagMeta (const std::string &name) override
	This method gets a tag meta info by the tag name from the file storage. More...
IovSetDto	selectIovs (const std::string &name, uint64_t since, uint64_t until, long snapshot, int size, int page, const std::string &sort) override
	This method selects IOVs for a given tagname from the file storage. More...
IovSetDto	selectGroups (const std::string &name, long snapshot, int size, int page, const std::string &sort) override
	This method returns IOV groups for a given tagname. More...
void	createGlobalTagMap (GlobalTagMapDto &globalTagMap) override
	This method creates a global tag map on the file storage. More...
GlobalTagMapSetDto	findGlobalTagMap (const std::string &name, const std::string &xCrestMapMode) override
	This method searches for tag mappings using the global tag name or tag name on the file storage. More...
void	removeGlobalTagMap (const std::string &name, const std::string &record, const std::string &label, const std::string &tagname) override
	This method removes a global tag map from the file storage. More...
void	storeData (const std::string &tag, const StoreSetDto &storeSetJson, const std::string &payloadFormat="JSON", const std::string &objectType="none", const std::string &compressionType="none", const std::string &version="1.0", uint64_t endTime=-1) override
	This method stores several payloads in batch mode on the file storage. More...
std::string	getPayload (const std::string &hash) override
	This method finds a payload resource associated to the hash on the file storage. More...
PayloadDto	getPayloadMeta (const std::string &hash) override
	This method finds a payload meta info for the hash on the file storage. More...
std::string	getCrestVersion () override
	This method returns the full CREST Server version. More...

Protected Member Functions
std::string	getHash (std::string_view str)
	This method method calculates the hash for string. More...
std::string	getHashForFile (const std::string &file)
	This method method calculates the hash for a file. More...
const std::string &	getClientVersion ()
	This method returns the full CrestApi version. More...

Private Member Functions
void	checkFsException (const char *method_name)
	Auxiliary method to check if the CrestApi library initialized to work with the file system. More...
std::string	getFileString (const std::string &path)
	Auxiliary method to get a file as a string. More...
void	getFileList (const std::string &path)
	Auxiliary method to get a file list in the given directory. More...
void	flush ()
	Auxiliary method flush the data to the file system. More...
std::string	getDateAndTime ()
std::string	getFirstLetters (const std::string &str)
	This is an auxillary method extract first letters from the string (hash). More...
nlohmann::json	getPage (nlohmann::json data, int size, int page)
std::vector< std::string >	getVectorPage (const std::vector< std::string > &data, int size, int page)
std::vector< std::string >	nameList (std::string &folder, bool ascending=true)
std::string	buildPath (const std::string &path, const std::string &file)
nlohmann::json	sortJson (nlohmann::json js, const std::string &par, bool order)
nlohmann::json	sortIOVJson (nlohmann::json js, bool order)
bool	isMatch (const std::string &word, long unsigned int n, const std::string &pattern, long unsigned int m)
bool	isMatch (const std::string &word, const std::string &pattern)
nlohmann::json	findAllIovs (const std::string &tagname)
	This auxiliary method finds all iovs for a given tag name. More...
void	storePayloadDump (const std::string &tag, uint64_t since, const std::string &js, const std::string &payloadFormat, const std::string &objectType, const std::string &compressionType, const std::string &version, const std::string &streamerInfo)
	This auxiliary method stores a single payload (with since time) on the file system. More...

Private Attributes
std::string	m_root_folder {}
std::string	m_data_folder {}
std::map< std::string, nlohmann::json >	m_data {}
bool	m_isRewrite {}
std::string	m_currentTag {}

Static Private Attributes
static const std::string	s_FS_TAG_PATH = "/tags"
static const std::string	s_FS_GLOBALTAG_PATH = "/globaltags"
static const std::string	s_FS_DATA_PATH = "/data"
static const std::string	s_FS_TAG_FILE = "/tag.json"
static const std::string	s_FS_IOV_FILE = "/iovs.json"
static const std::string	s_FS_TAGMETAINFO_FILE = "/tagmetainfo.json"
static const std::string	s_FS_META_FILE = "/meta.json"
static const std::string	s_FS_PALOAD_FILE = "/payload.json"
static const std::string	s_FS_GLOBALTAG_FILE = "/globaltag.json"
static const std::string	s_FS_MAP_FILE = "/maps.json"
static const std::string	s_FS_PATH = ""
static const int	s_FS_PREFIX_LENGTH = 3
static const std::string	s_CREST_CLIENT_VERSION = "5.0"

Detailed Description

Definition at line 31 of file CrestApiFs.h.

Constructor & Destructor Documentation

CrestFsClient()

Crest::CrestFsClient::CrestFsClient	(	bool	rewriteIfExists,
		const std::string &	root_folder
	)

CrestFsClient constructor.

CrestFsClient constructor for Internet mode.

Parameters

rewriteIfExist	- this parameter sets if the data can be rewritten.
root_folder	- the folder where the data have to be stored.

If CrestClient is created with this method the data will be sent to the CREST Server.

Parameters

rewriteIfExists	- Boolean flag to reinitialize the file system.
root_folder	- root directory of the CREST storage.

Definition at line 35 of file CrestApiFs.cxx.

      : m_root_folder(root_folder), m_isRewrite(rewriteIfExists)
  {
    if (m_root_folder == "") {
      m_root_folder = std::filesystem::current_path();
      m_root_folder += "/crest";
    } 
    if (!std::filesystem::exists(std::filesystem::path(m_root_folder)))
    {
      std::filesystem::create_directory(std::filesystem::path(m_root_folder));
    }
    m_data_folder = m_root_folder + "/data";
    if (!std::filesystem::exists(std::filesystem::path(m_data_folder)))
    {
      std::filesystem::create_directory(std::filesystem::path(m_data_folder));
    }
  }

~CrestFsClient()

Crest::CrestFsClient::~CrestFsClient

(

)

CrestClient destructor.

Definition at line 56 of file CrestApiFs.cxx.

{}

Member Function Documentation

buildPath()

std::string Crest::CrestFsClient::buildPath ( const std::string &  path, const std::string &  file  )

private

Definition at line 67 of file CrestApiFs.cxx.

  {
    std::string p = m_root_folder;
    if (!std::filesystem::exists(std::filesystem::path(m_root_folder)))
    {
      std::filesystem::create_directory(std::filesystem::path(m_root_folder));
    }
    p += path;
    if (!std::filesystem::exists(std::filesystem::path(p)))
    {
      std::filesystem::create_directory(std::filesystem::path(p));
    }
    p += '/';
    p += name;
    if (!std::filesystem::exists(std::filesystem::path(p)))
    {
      std::filesystem::create_directory(std::filesystem::path(p));
    }
    return p;
  }

checkFsException()

void Crest::CrestFsClient::checkFsException ( const char *  method_name )

private

Auxiliary method to check if the CrestApi library initialized to work with the file system.

It was used to throw an exception if the library method not implemented for file system.

Parameters

method_name

- method name.

Definition at line 523 of file CrestApiFs.cxx.

  {
    throw CrestException("ERROR in " + std::string(method_name) + " This methods is unsupported for FILESYSTEM mode");
  }

createGlobalTag()

void Crest::CrestFsClient::createGlobalTag ( GlobalTagDto &  globalTag )

overridevirtual

This method creates a global tag on the file storage.

Parameters

globalTag

- global tag as GlobalTagDto.

Example:

 nlohmann::json js =
     {
         {"name", tagname},
         {"validity", 0},
         {"description", "test"},
         {"release", "1"},
         {"insertionTime", "2018-12-18T11:32:58.081+0000"},
         {"snapshotTime", "2018-12-18T11:32:57.952+0000"},
         {"scenario", "test"},
         {"workflow", "M"},
         {"type", "t"},
     };

 GlobalTagDto dto = GlobalTagDto();
 dto = dto.from_json(js);

 myCrestClient.createGlobalTag(dto);

Implements Crest::CrestApiBase.

Definition at line 106 of file CrestApiFs.cxx.

  {
    std::string name = "";
    if (globalTag.name != "")
    {
      name = globalTag.name;
    }
    else
    {
      throw CrestException("ERROR in CrestFsClient::createGlobalTag: global tag name is not set.");
    }
 
    std::string workDir = buildPath(s_FS_GLOBALTAG_PATH, name);
    std::string globalTagFile = workDir + s_FS_GLOBALTAG_FILE;
 
    if (m_isRewrite)
    {
      if (std::filesystem::exists(std::filesystem::path(globalTagFile)))
      {
        std::filesystem::remove(std::filesystem::path(globalTagFile));
      }
 
      std::ofstream outFile;
 
      outFile.open(globalTagFile.c_str());
      outFile << globalTag.to_json();
      outFile.close();
    }
 
    return;
  }

createGlobalTagMap()

void Crest::CrestFsClient::createGlobalTagMap ( GlobalTagMapDto &  globalTagMap )

overridevirtual

This method creates a global tag map on the file storage.

Parameters

globalTagMap

- the global tag map as GlobalTagMapDto.

Example:

 nlohmann::json js =
 {
   {"globalTagName", globaltag},
   {"record", "testing2"},
   {"label", "test2"},
   {"tagName", tagname}
 };

 GlobalTagMapDto globalTagMap = GlobalTagMapDto();
 globalTagMap = globalTagMap.from_json(js);

 myCrestClient.createGlobalTagMap(globalTagMap);

Implements Crest::CrestApiBase.

Definition at line 431 of file CrestApiFs.cxx.

  {
    nlohmann::json js = globalTagMap.to_json();
 
    // global tag name:
    std::string name = "";
    try
    {
      name = static_cast<std::string>(js["globalTagName"]);
    }
    catch (...)
    {
      throw CrestException("ERROR in CrestClient::createGlobalTagMap: cannot get the global tag name from JSON.");
    }
 
    // tag name:
    std::string tagname = "";
    try
    {
      tagname = static_cast<std::string>(js["tagName"]);
    }
    catch (...)
    {
      throw CrestException("ERROR in CrestClient::createGlobalTagMap: cannot get the tag name from JSON.");
    }
 
    std::string workDir = buildPath(s_FS_GLOBALTAG_PATH, name);
    std::string catalogFile = workDir + s_FS_MAP_FILE;
 
    if (std::filesystem::exists(std::filesystem::path(catalogFile)))
    {
      // cathalogue file exists:
 
      std::string array_lst = getFileString(catalogFile);
 
      nlohmann::json cathalogue;
      try
      {
        cathalogue = nlohmann::json::parse(array_lst);
      }
      catch (...)
      {
        throw CrestException("ERROR in CrestFsClient::createGlobalTagMap: global tag map file corrupted.");
      }
 
      if (std::filesystem::exists(std::filesystem::path(catalogFile)))
      {
        // the file storage contains the record of the global tag map:
        int m = cathalogue.size();
        for (int i = 0; i < m; i++)
        {
          const std::string &tn = cathalogue[i]["tagName"];
          if (tn == tagname)
          {
            cathalogue.erase(i);
          }
        }
      }
      else
      {
        // the file storage does not contain the record of the global tag map:
      }
      std::filesystem::remove(std::filesystem::path(catalogFile));
      cathalogue.push_back(js);
      std::ofstream outFile;
 
      outFile.open(catalogFile.c_str());
      outFile << cathalogue;
      outFile.close();
    }
    else
    {
      // cathalogue file does not exist (creation):
 
      nlohmann::json cathalogue = nlohmann::json::array();
      cathalogue.push_back(js);
 
      std::ofstream outFile;
 
      outFile.open(catalogFile.c_str());
      outFile << cathalogue;
      outFile.close();
    }
 
    return;
  }

createTag()

void Crest::CrestFsClient::createTag ( TagDto &  tag )

overridevirtual

This method creates a tag on the file storage.

Parameters

tag	- tag as TagDto.

 Example:

 nlohmann::json js =
 {
   {"name", tagname},
   {"timeType", "time"},
   {"description", "test"},
   {"synchronization", "none"},
   {"insertionTime", "2018-12-18T11:32:58.081+0000"},
   {"modificationTime", "2018-12-18T11:32:57.952+0000"},
   {"payloadSpec", "JSON"},
   {"lastValidatedTime", 0.},
   {"endOfValidity", 0.},
 };

 TagDto dto = TagDto();
 dto = dto.from_json(js);

 myCrestClient.createTag(dto);

Implements Crest::CrestApiBase.

Definition at line 233 of file CrestApiFs.cxx.

  {
    std::string name = tag.name;
    std::string workDir = buildPath(s_FS_TAG_PATH, name);
 
    if (name.compare(m_currentTag) != 0 && m_isRewrite)
    {
      flush();
    }
    m_currentTag = name;
    std::string tagFile = workDir + s_FS_TAG_FILE;
    std::string iovFile = workDir + s_FS_IOV_FILE;
 
    if (m_isRewrite)
    {
      if (std::filesystem::exists(std::filesystem::path(tagFile)))
      {
        std::filesystem::remove(std::filesystem::path(tagFile));
      }
      if (std::filesystem::exists(std::filesystem::path(iovFile)))
      {
        std::filesystem::remove(std::filesystem::path(iovFile));
      }
      std::ofstream outFile;
      outFile.open(tagFile.c_str());
      outFile << tag.to_json();
      outFile.close();
    }
    if (m_data.find(name) == m_data.end())
    {
      m_data.insert(std::pair<std::string, nlohmann::json>(name, nlohmann::json(nlohmann::json::value_t::array)));
    }
  }

createTagMeta()

void Crest::CrestFsClient::createTagMeta ( TagMetaDto &  tag )

overridevirtual

This method creates a tag meta info on the file storage.

Parameters

tag	- tag meta info as TagMetaDto.

Example:

 nlohmann::json channel = {{"0", "ATLAS_PREFERRED"}};

 nlohmann::json chanList = nlohmann::json::array({channel});

 nlohmann::json tagInfo =
     {
         {"channel_list", chanList},
         {"node_description", "description of the node"},
         {"payload_spec", "stave:Int32, eta:Int32, mag:Float, base:Float, free:Float"}};

 nlohmann::json js =
     {
         {"tagName", tagname},
         {"description", "none"},
         {"chansize", 1},
         {"colsize", 6},
         {"tagInfo", tagInfo.dump()},
         {"insertionTime", "2020-12-04"}};

 TagMetaDto dto = TagMetaDto();
 dto = dto.from_json(js);

 myCrestClient.createTagMeta(dto);

Implements Crest::CrestApiBase.

Definition at line 379 of file CrestApiFs.cxx.

  {
    std::string name = tag.tagName;
 
    std::string workDir = buildPath(s_FS_TAG_PATH, name);
    std::string tagMetaFile = workDir + s_FS_TAGMETAINFO_FILE;
 
    if (m_isRewrite)
    {
      if (std::filesystem::exists(std::filesystem::path(tagMetaFile)))
      {
        std::filesystem::remove(std::filesystem::path(tagMetaFile));
      }
 
      std::ofstream outFile;
 
      outFile.open(tagMetaFile.c_str());
      outFile << tag.to_json();
      outFile.close();
    }
  }

findAllIovs()

nlohmann::json Crest::CrestFsClient::findAllIovs ( const std::string &  tagname )

private

This auxiliary method finds all iovs for a given tag name.

The result is a JSON object.

Parameters

tagname

- tag name.

Returns

JSON array with the IOV list. Example:

IOV list =
[
   {
      "tagName": "CaloOflHadDMCorr2-R123-FTFP-BERT-IOVDEP-01",
      "since": 0,
      "insertionTime": "2023-09-13T12:53:46+0000",
      "payloadHash": "ba26ca6b4e17b0c33b008045c5e703bdf049a1546e731ec7c3d2d39789b1ce1f"
  },
  ...
]

IOV JSON parameters:

 tagName          string              tag name
 since            number              since time parameter
 insertionTime    string($date-time)  insertion time
 payloadHash      string              payload hash

Definition at line 621 of file CrestApiFs.cxx.

  {
    nlohmann::json js = nullptr;
    std::string file_path = m_root_folder;
    file_path += '/';
    file_path += s_FS_TAG_PATH;
    file_path += '/';
    file_path += tagname;
    file_path += s_FS_IOV_FILE;
 
    try
    {
      std::string tag = getFileString(file_path);
      js = nlohmann::json::parse(tag);
    }
    catch (const std::exception &e)
    {
      throw CrestException("ERROR in CrestFsClient::findAllIovs : cannot get the iov information form file storage "); 
    }
 
    return js;
  }

findGlobalTag()

GlobalTagDto Crest::CrestFsClient::findGlobalTag ( const std::string &  name )

overridevirtual

This method finds a global tag by name on the file storage.

Only one global tag should be returned. (This method is an analogue of the find_global_tag method in Python)

Parameters

name	- global tag name,

Returns

global tag as GlobalTagDto.

Implements Crest::CrestApiBase.

Definition at line 138 of file CrestApiFs.cxx.

  {
    nlohmann::json js = nullptr;
    GlobalTagDto dto;
 
    std::string workDir = buildPath(s_FS_GLOBALTAG_PATH, name);
    std::string file_path = workDir + s_FS_GLOBALTAG_FILE;
 
    try
    {
      std::string tag = getFileString(file_path);
      js = nlohmann::json::parse(tag);
      dto = GlobalTagDto::from_json(js);
    }
    catch (...)
    {
      throw CrestException(
          "ERROR in CrestFsClient::findGlobalTag: cannot get the global tag " + name + " form the file storage.");
    }
 
    return dto;
  }

findGlobalTagMap()

GlobalTagMapSetDto Crest::CrestFsClient::findGlobalTagMap ( const std::string &  name, const std::string &  xCrestMapMode  )

overridevirtual

This method searches for tag mappings using the global tag name or tag name on the file storage.

(This method is an analogue of the find_global_tag_map method in Python)

Parameters

name	- name of a global tag or a tag
xCrestMapMode	- search mode (Trace or BackTrace). If it is set as "Trace" the global tag name will be used for searching, otherwise - the tag name.

Returns

global tag map list as GlobalTagMapSetDto.

Implements Crest::CrestApiBase.

Definition at line 528 of file CrestApiFs.cxx.

  {
 
    nlohmann::json js = nullptr;
 
    if (xCrestMapMode != "Trace")
    {
      throw CrestException(
          "ERROR in CrestFsClient::getGlobalTagMap: not supported value for the parameter xCrestMapMode = " + xCrestMapMode);
    }
 
    std::string workDir = m_root_folder + s_FS_GLOBALTAG_PATH;
    std::string file_path = workDir;
    file_path += '/';
    file_path += name;
    file_path += s_FS_MAP_FILE;
 
    try
    {
      std::string tag = getFileString(file_path);
      js = nlohmann::json::parse(tag);
    }
    catch (...)
    {
      throw CrestException(
          "ERROR in CrestFsClient::getGlobalTagMap: cannot get the global tag map " + name +
          " form the file storage.");
    }
 
    GlobalTagMapSetDto dto;
    dto = GlobalTagMapSetDto::from_fs_json(js);
    return dto;
  }

findTag()

TagDto Crest::CrestFsClient::findTag ( const std::string &  name )

overridevirtual

This method finds a tag by the name on the file storage.

(This method is an analogue of the find_tag method in Python)

Parameters

name	- tag name

Returns

tag as TagDto object.

Implements Crest::CrestApiBase.

Definition at line 267 of file CrestApiFs.cxx.

  {
    nlohmann::json js = nullptr;
    TagDto dto;
 
    std::string workDir = buildPath(s_FS_TAG_PATH, name);
    std::string file_path = workDir + s_FS_TAG_FILE;
 
    try
    {
      std::string tag = getFileString(file_path);
      js = nlohmann::json::parse(tag);
      dto = TagDto::from_json(js);
    }
    catch (...)
    {
      throw CrestException(
          "ERROR in CrestFsClient::findTag: cannot get the tag " + name + " form the file storage.");
    }
 
    return dto;
  }

findTagMeta()

TagMetaDto Crest::CrestFsClient::findTagMeta ( const std::string &  name )

overridevirtual

This method gets a tag meta info by the tag name from the file storage.

Parameters

name	- tag name

Returns

tag meta info as a TagMetaDto.

Implements Crest::CrestApiBase.

Definition at line 406 of file CrestApiFs.cxx.

  {
    nlohmann::json js = nullptr;
    TagMetaDto dto;
 
    std::string workDir = buildPath(s_FS_TAG_PATH, name);
    std::string file_path = workDir + s_FS_TAGMETAINFO_FILE;
 
    try
    {
      std::string tag = getFileString(file_path);
      js = nlohmann::json::parse(tag);
      dto = TagMetaDto::from_json(js);
    }
    catch (...)
    {
      throw CrestException(
          "ERROR in CrestFsClient::findTagMeta: cannot get the tag " + name + " form the file storage.");
    }
 
    return dto;
  }

flush()

void Crest::CrestFsClient::flush ( )

private

Auxiliary method flush the data to the file system.

Definition at line 360 of file CrestApiFs.cxx.

  {
 
    for (auto &item : m_data)
    {
      nlohmann::json iov = item.second;
      std::string name = item.first;
      std::string workDir = m_root_folder + s_FS_TAG_PATH + '/' + name;
      std::ofstream outFile;
      std::string tagFile = workDir + s_FS_IOV_FILE;
      outFile.open(tagFile.c_str());
      outFile << iov;
      outFile.close();
    }
 
    m_data.clear();
  }

getClientVersion()

const std::string & Crest::CrestApiBase::getClientVersion ( )

protectedinherited

This method returns the full CrestApi version.

Returns

CrestApi library version.

Definition at line 38 of file CrestApiBase.cxx.

  {
    return s_CREST_CLIENT_VERSION;
  }

getCrestVersion()

std::string Crest::CrestFsClient::getCrestVersion ( )

overridevirtual

This method returns the full CREST Server version.

Returns

CREST server version.

Implements Crest::CrestApiBase.

Definition at line 1111 of file CrestApiFs.cxx.

  {
    throw CrestException(
      "ERROR in CrestFsClient::getCrestVersion: cannot get the CREST server version for file storage.");
  }

getDateAndTime()

std::string Crest::CrestFsClient::getDateAndTime ( )

private

Definition at line 711 of file CrestApiFs.cxx.

  {
    time_t now = time(0);
    struct tm tstruct;
    char buf[80];
 
    localtime_r(&now, &tstruct);
    strftime(buf, sizeof(buf), "%Y-%m-%d %X", &tstruct);
    return buf;
  }

getFileList()

void Crest::CrestFsClient::getFileList ( const std::string &  path )

private

Auxiliary method to get a file list in the given directory.

(The old method name - get_file_list)

Parameters

path	- path to the directory.

Definition at line 88 of file CrestApiFs.cxx.

  {
    std::filesystem::path p(path);
    for (auto i = std::filesystem::directory_iterator(p); i != std::filesystem::directory_iterator(); i++)
    {
      std::string file = i->path().filename().string();
      if (file != "data")
      {
        std::cout << file << std::endl;
      }
      else{
        continue;
      }
    }
  }

getFileString()

std::string Crest::CrestFsClient::getFileString ( const std::string &  path )

private

Auxiliary method to get a file as a string.

(The old method name - get_file_string)

Parameters

path	- path to the file.

Definition at line 60 of file CrestApiFs.cxx.

                                                              {
    std::ifstream ifs(path);
    std::stringstream buf;
    buf << ifs.rdbuf();
    return buf.str();
  }

getFirstLetters()

std::string Crest::CrestFsClient::getFirstLetters ( const std::string &  str )

private

This is an auxillary method extract first letters from the string (hash).

The letter number is in the s_FS_PREFIX_LENGTH variable. This method is used to create a catalogue sub directory in the file storage.

Parameters

str	- string to extract first letters.

Returns

- string with first letters

Definition at line 722 of file CrestApiFs.cxx.

  {
    std::string result = str.substr(0, s_FS_PREFIX_LENGTH);
    return result;
  }

getHash()

std::string Crest::CrestApiBase::getHash ( std::string_view  str )

protectedinherited

This method method calculates the hash for string.

Parameters

str

- string.

Returns

hash for a given string.

Definition at line 32 of file CrestApiBase.cxx.

  {
    std::string hash_hex_str = picosha2::hash256_hex_string(str.begin(), str.end());
    return hash_hex_str;
  }

getHashForFile()

std::string Crest::CrestApiBase::getHashForFile ( const std::string &  file )

protectedinherited

This method method calculates the hash for a file.

Parameters

file	- path to the file with the file name..

Returns

hash for a given file.

Definition at line 8 of file CrestApiBase.cxx.

  {
    std::ifstream ifs(file);
    if (!ifs)
    {
      throw CrestException(
          "ERROR in CrestFsClient::getHashForFile cannot open file \"" + file + "\".");
    }
 
    picosha2::hash256_one_by_one hasher;
    std::vector<char> buffer(1024 * 1024); // use 1M memory
    while (ifs.read(buffer.data(), static_cast<std::streamsize>(buffer.size())))
    {
      std::cout << "#" << std::flush;
      hasher.process(buffer.begin(), buffer.end());
    }
    // process remains
    hasher.process(buffer.begin(), buffer.begin() + static_cast<int>(ifs.gcount()));
    hasher.finish();
 
    std::string hash = picosha2::get_hash_hex_string(hasher);
    return hash;
  }

getPage()

nlohmann::json Crest::CrestFsClient::getPage ( nlohmann::json  data, int  size, int  page  )

private

Definition at line 921 of file CrestApiFs.cxx.

  {
    nlohmann::json js = nlohmann::json::array();
    int dataSize = data.size();
 
    if (dataSize == 0)
      return js; // the data is absent
 
    // index interval to load the data from JSON array:
    int kmin = size * page;
    int kmax = size * (page + 1);
 
    // check if the interval is correct:
    if (kmin > dataSize - 1)
      return js; // out of range
 
    if (kmax > dataSize - 1)
    { // this step is not full
      kmax = dataSize;
    }
 
    for (int i = kmin; i < kmax; i++)
    {
      js.push_back(data[i]);
    }
    return js;
  }

getPayload()

std::string Crest::CrestFsClient::getPayload ( const std::string &  hash )

overridevirtual

This method finds a payload resource associated to the hash on the file storage.

The payload returns as a string. (This method is an analogue of the get_payload method in Python)

Parameters

hash

- hash.

Returns

payload as a std::string

Implements Crest::CrestApiBase.

Definition at line 853 of file CrestApiFs.cxx.

  {
    std::string workDir = m_data_folder;
    workDir += '/';
    workDir += getFirstLetters(hash);
    workDir += '/';
    workDir += hash;
    std::string filePath = workDir + "/payload.json";
    std::string res = "";
 
    try
    {
      if (std::filesystem::exists(filePath))
      {
        res = getFileString(filePath);
      }
      else
      {
        throw CrestException("payload with hash " + hash + " does not exist.");
      }
    }
    catch (const std::exception &e)
    {
      std::string message = e.what();
      throw CrestException("ERROR in CrestFsClient::getPayload cannot get the payload form file storage, " + message);
    }
 
    return res;
  }

getPayloadMeta()

PayloadDto Crest::CrestFsClient::getPayloadMeta ( const std::string &  hash )

overridevirtual

This method finds a payload meta info for the hash on the file storage.

(This method is an analogue of the get_payload_meta method in Python)

Parameters

hash

- hash.

Returns

payload meta info as PayloadDto.

Implements Crest::CrestApiBase.

Definition at line 883 of file CrestApiFs.cxx.

  {
    nlohmann::json js = nullptr;
    PayloadDto dto;
 
    std::string workDir = m_data_folder;
    workDir += '/';
    workDir += getFirstLetters(hash);
    workDir += '/';
    workDir += hash;
 
    std::string filePath = workDir;
    filePath += "/meta.json";
 
    std::string res = "";
 
    try
    {
      if (std::filesystem::exists(filePath))
      {
        res = getFileString(filePath);
        js = nlohmann::json::parse(res);
        dto = PayloadDto::from_json(js);
      }
      else
      {
        throw CrestException("payload meta info with hash " + hash + " does not exist.");
      }
    }
    catch (const std::exception &e)
    {
      std::string message = e.what();
      throw CrestException("ERROR in CrestClient::getPayloadMeta cannot get the payload meta info form file storage, " + message);
    }
 
    return dto;
  }

getSize()

int Crest::CrestFsClient::getSize ( const std::string &  tagname )

overridevirtual

This method gets the number of IOVs for the given tag.

(This method is an analogue of the get_size method in Python)

Parameters

tagname

- tag name.

Returns

IOV number.

Implements Crest::CrestApiBase.

Definition at line 644 of file CrestApiFs.cxx.

  {
    int res = 0;
 
    try
    {
      nlohmann::json iovs = findAllIovs(tagname);
      int length = iovs.size();
      return length;
    }
    catch (...)
    {
      return res;
    }
 
    return res;
  }

getVectorPage()

std::vector< std::string > Crest::CrestFsClient::getVectorPage ( const std::vector< std::string > &  data, int  size, int  page  )

private

Definition at line 949 of file CrestApiFs.cxx.

  {
    std::vector<std::string> res;
    int dataSize = data.size();
 
    if (dataSize == 0)
      return res; // the data is absent
 
    // index interval to load the data from JSON array:
    int kmin = size * page;
    int kmax = size * (page + 1);
 
    // check if the interval is correct:
    if (kmin > dataSize - 1)
      return res; // out of range
 
    if (kmax > dataSize - 1)
    { // this step is not full
      kmax = dataSize;
    }
 
    for (int i = kmin; i < kmax; i++)
    {
      res.push_back(data[i]);
    }
    return res;
  }

isMatch() [1/2]

bool Crest::CrestFsClient::isMatch ( const std::string &  word, const std::string &  pattern  )

private

Definition at line 1106 of file CrestApiFs.cxx.

  {
    return isMatch(word, 0, pattern, 0);
  }

isMatch() [2/2]

bool Crest::CrestFsClient::isMatch ( const std::string &  word, long unsigned int  n, const std::string &  pattern, long unsigned int  m  )

private

Definition at line 1073 of file CrestApiFs.cxx.

  {
    if (m == pattern.size())
    {
      return n == word.size();
    }
 
    if (n == word.size())
    {
      for (long unsigned int i = m; i < pattern.size(); i++)
      {
        if (pattern[i] != '%')
        {
          return false;
        }
      }
 
      return true;
    }
 
    if (pattern[m] == '?' || pattern[m] == word[n])
    {
      return isMatch(word, n + 1, pattern, m + 1);
    }
 
    if (pattern[m] == '%')
    {
      return isMatch(word, n + 1, pattern, m) || isMatch(word, n, pattern, m + 1);
    }
 
    return false;
  }

listGlobalTags()

GlobalTagSetDto Crest::CrestFsClient::listGlobalTags ( const std::string &  name, int  size, int  page, const std::string &  sort  )

overridevirtual

This method finds the global tags on the file storage.

Parameters

name	- global tag name pattern, "%" can be used for any symbols,
size	- page size,
page	- page number,
sort	- sorting order (name:ASC or name:DESC),

Returns

global tag list as GlobalTagSetDto.

Implements Crest::CrestApiBase.

Definition at line 166 of file CrestApiFs.cxx.

  {
 
    std::string folder = m_root_folder + s_FS_GLOBALTAG_PATH;
 
    GlobalTagSetDto tagSet;
 
    bool ascending = true;
    if (sort == "name:ASC")
    {
      ascending = true;
    }
    else if (sort == "name:DESC")
    {
      ascending = false;
    }
    else
    {
      throw CrestException(
          "ERROR in CrestFsClient::listTags: wrong sort parameter." + sort);
    }
 
    try
    {
      std::vector<std::string> taglist = nameList(folder, ascending);
      std::vector<std::string> clearedTaglist;
 
      for (const std::string& tag : taglist)
      {
        std::string file_name = folder + "/" + tag + "/" + s_FS_GLOBALTAG_FILE;
 
        if (std::filesystem::exists(file_name))
        {
          if (name != "")
          {
            if (isMatch(tag, name))
            {
              clearedTaglist.push_back(tag);
            }
          }
          else
          {
            clearedTaglist.push_back(tag);
          }
        }
      }
 
      taglist = getVectorPage(clearedTaglist, size, page);
      for (const std::string& tag : taglist)
      {
        std::string file_name = folder + "/" + tag + "/" + s_FS_GLOBALTAG_FILE;
        GlobalTagDto dto = findGlobalTag(tag);
        tagSet.resources.push_back(dto);
      }
      tagSet.datatype = "";
    }
    catch (const std::exception &e)
    {
      throw CrestException(
          "ERROR in CrestFsClient::listGlobalTags: cannot get the tag list.");
    }
 
    return tagSet;
  }

listTags()

TagSetDto Crest::CrestFsClient::listTags ( const std::string &  name, int  size, int  page, const std::string &  sort  )

overridevirtual

This method returns the tag list as TagSetDto.

(This method is an analogue of the list_tags method in Python)

Parameters

name	- tag name pattern,
size	- page size,
page	- page number,
sort	- sorting order (name:ASC or name:DESC).

Returns

tag list as TagSetDto object.

Implements Crest::CrestApiBase.

Definition at line 295 of file CrestApiFs.cxx.

  {
 
    std::string folder = m_root_folder + s_FS_TAG_PATH;
 
    TagSetDto tagSet;
 
    bool ascending = true;
    if (sort == "name:ASC")
    {
      ascending = true;
    }
    else if (sort == "name:DESC")
    {
      ascending = false;
    }
    else
    {
      throw CrestException(
          "ERROR in CrestFsClient::listTags: wrong sort parameter." + sort);
    }
 
    try
    {
      std::vector<std::string> taglist = nameList(folder, ascending);
      std::vector<std::string> clearedTaglist;
 
      for (const std::string& tag : taglist)
      {
        std::string file_name = folder + "/" + tag + "/" + s_FS_TAG_FILE;
 
        if (std::filesystem::exists(file_name))
        {
          if (name != "")
          {
            if (isMatch(tag, name))
            {
              clearedTaglist.push_back(tag);
            }
          }
          else
          {
            clearedTaglist.push_back(tag);
          }
        }
      }
 
      taglist = getVectorPage(clearedTaglist, size, page);
      for (const std::string& tag : taglist)
      {
        std::string file_name = folder + "/" + tag + "/" + s_FS_TAG_FILE;
        TagDto dto = findTag(tag);
        tagSet.resources.push_back(dto);
      }
      tagSet.datatype = "";
    }
    catch (const std::exception &e)
    {
      throw CrestException(
          "ERROR in CrestFsClient::listTags: cannot get the tag list.");
    }
 
    return tagSet;
  }

nameList()

std::vector< std::string > Crest::CrestFsClient::nameList ( std::string &  folder, bool  ascending = true  )

private

Definition at line 977 of file CrestApiFs.cxx.

  {
    std::vector<std::string> tag_list;
    std::filesystem::path p(folder);
 
    for (auto i = std::filesystem::directory_iterator(p); i != std::filesystem::directory_iterator(); i++)
    {
      std::string file = i->path().filename().string();
      tag_list.push_back(file);
    }
 
    std::sort(tag_list.begin(), tag_list.end());
 
    if (ascending == false)
    {
      std::reverse(tag_list.begin(), tag_list.end());
    }
 
    return tag_list;
  }

removeGlobalTag()

void Crest::CrestFsClient::removeGlobalTag ( const std::string &  name )

overridevirtual

This method removes a global tag.

(This method is an analogue of the remove_global_tag method in Python)

Parameters

name	- global tag name

Implements Crest::CrestApiBase.

Definition at line 161 of file CrestApiFs.cxx.

  {
    checkFsException("CrestFsClient::removeGlobalTag");
  }

removeGlobalTagMap()

void Crest::CrestFsClient::removeGlobalTagMap ( const std::string &  name, const std::string &  record, const std::string &  label, const std::string &  tagname  )

overridevirtual

This method removes a global tag map from the file storage.

Parameters

name	- the global tag name,
label	- label,
tagname	- tag name.

Implements Crest::CrestApiBase.

Definition at line 518 of file CrestApiFs.cxx.

  {
    checkFsException("CrestFsClient::removeGlobalTagMap");
  }

removeTag()

void Crest::CrestFsClient::removeTag ( const std::string &  name )

overridevirtual

This method removes a tag from the file storage.

(This method is an analogue of the remove_tag method in Python)

Parameters

tagName

- tag name

Implements Crest::CrestApiBase.

Definition at line 290 of file CrestApiFs.cxx.

  {
    checkFsException("CrestFsClient::removeTag");
  }

selectGroups()

IovSetDto Crest::CrestFsClient::selectGroups ( const std::string &  name, long  snapshot, int  size, int  page, const std::string &  sort  )

overridevirtual

This method returns IOV groups for a given tagname.

The result is an IOV list. (This method is an analogue of the select_groups method in Python)

Parameters

name	- tag name,
snapshot	- snapshot,
size	- page size,
page	- page number,
sort	- sorting order (id.since:ASC or id.since:DESC)

Returns

an IOV groups as IovSetDto.

Implements Crest::CrestApiBase.

Definition at line 662 of file CrestApiFs.cxx.

  {
    checkFsException("CrestFsClient::selectGroups");
    return IovSetDto();
  }

selectIovs()

IovSetDto Crest::CrestFsClient::selectIovs ( const std::string &  name, uint64_t  since, uint64_t  until, long  snapshot, int  size, int  page, const std::string &  sort  )

overridevirtual

This method selects IOVs for a given tagname from the file storage.

The result is an IOV list. (This method is an analogue of the select_iovs method in Python)

Parameters

name	- tag name,
since	- since time (the beginning of the time interval),
until	- until time (end of the time interval),
snapshot	- snapshot,
size	- page size,
page	- page number,
sort	- sorting order (id.since:ASC or id.since:DESC)

Returns

an IOV list as IovSetDto.

Implements Crest::CrestApiBase.

Definition at line 564 of file CrestApiFs.cxx.

  {
    IovSetDto dto;
 
    nlohmann::json js = nlohmann::json::array();
 
    try
    {
      nlohmann::json iovList = findAllIovs(name);
      int niovs = iovList.size();
 
      for (int i = 0; i < niovs; i++)
      {
        if (iovList[i].find("since") != iovList[i].end())
        {
          uint64_t currentS = iovList[i]["since"];
 
          if (until != static_cast<uint64_t>(-1))
          {
            if (currentS >= since && currentS <= until)
            {
              js.push_back(iovList[i]);
            }
          }
          else
          { // until == -1, Infinity
            if (currentS >= since)
            {
              js.push_back(iovList[i]);
            }
          } // until == -1
        }
      } // for
    }
    catch (...)
    {
      throw CrestException("ERROR in CrestClient::selectIovsFS : cannot get the iov list form file storage");
    }
 
    bool ascending = true;
    if (sort == "id.since:ASC")
      ascending = true;
    else if (sort == "id.since:DESC")
      ascending = false;
    else
    {
      throw CrestException(
          "ERROR in CrestFsClient::selectIovs: wrong sort parameter." + sort);
    }
 
    nlohmann::json sorted = sortIOVJson(js, ascending);
    nlohmann::json ext = getPage(sorted, size, page);
    dto = IovSetDto::from_fs_json(ext);
 
    return dto;
  }

sortIOVJson()

nlohmann::json Crest::CrestFsClient::sortIOVJson ( nlohmann::json  js, bool  order  )

private

Definition at line 1036 of file CrestApiFs.cxx.

  {
    std::string par = "since";
    nlohmann::json respond = nlohmann::json::array();
    std::vector<double> parlist;
    std::map<double, nlohmann::json> m;
 
    int size = js.size();
    for (int i = 0; i < size; i++)
    {
      nlohmann::json elem = js[i];
 
      auto res = elem.find(par);
 
      if (res != elem.end())
      {
        double par_val = elem[par];
        parlist.push_back(par_val);
        m[par_val] = elem;
      }
    }
 
    std::sort(parlist.begin(), parlist.end());
 
    if (order == false)
    {
      std::reverse(parlist.begin(), parlist.end());
    }
 
    for (double item : parlist)
    {
      respond.push_back(m[item]);
    }
 
    return respond;
  }

sortJson()

nlohmann::json Crest::CrestFsClient::sortJson ( nlohmann::json  js, const std::string &  par, bool  order  )

private

Definition at line 999 of file CrestApiFs.cxx.

  {
    nlohmann::json respond = nlohmann::json::array();
    std::vector<std::string> parlist;
    std::map<std::string, nlohmann::json> m;
 
    int size = js.size();
    for (int i = 0; i < size; i++)
    {
      nlohmann::json elem = js[i];
 
      auto res = elem.find(par);
 
      if (res != elem.end())
      {
        std::string par_val = elem[par];
        parlist.push_back(par_val);
        m[par_val] = elem;
      }
    }
 
    std::sort(parlist.begin(), parlist.end());
 
    if (order == false)
    {
      std::reverse(parlist.begin(), parlist.end());
    }
 
    for (std::string item : parlist)
    {
      respond.push_back(m[item]);
    }
 
    return respond;
  }

storeData()

void Crest::CrestFsClient::storeData ( const std::string &  tag, const StoreSetDto &  storeSetJson, const std::string &  payloadFormat = "JSON", const std::string &  objectType = "none", const std::string &  compressionType = "none", const std::string &  version = "1.0", uint64_t  endTime = -1  )

overridevirtual

This method stores several payloads in batch mode on the file storage.

(This method is an analogue of the store_data method in Python)

Parameters

tag	- tag name.
storeSetJson	- iov and payload data as a JSON object.
payloadFormat	- payload format [FILE | JSON].
objectType	- object type.
compressionType	- compression type.
version	- version.
endTime	- end time, if endtime = 0, the server does not use this parameter in the internal check.

Example how to use these parameters:

   std::string tag = "test_MvG3a";
   uint64_t endtime = 200;
   std::string objectType = "test";
   std::string compressionType = "none";
   std::string version = "1.0";
   std::string payloadFormat = "JSON";
   std::string jsonString = R"({"size": 1, "datatype": "data", "format": "StoreSetDto", "resources": [{"since": 1000,"data": "Sample data","streamerInfo": "Info123"}]})";
   StoreSetDto storeSetJson = StoreSetDto::from_json(jsonString);

Implements Crest::CrestApiBase.

Definition at line 669 of file CrestApiFs.cxx.

  {
    std::string name = tag;
 
    std::string workDir = buildPath(s_FS_TAG_PATH, name);
    std::string tagFile = workDir + s_FS_TAG_FILE;
    std::string iovFile = workDir + s_FS_IOV_FILE;
 
    nlohmann::json js_data = storeSetJson.to_json();
 
    nlohmann::json res;
    auto it = js_data.find("resources");
    if (it != js_data.end())
    {
      res = js_data["resources"];
    }
 
    try
    {
      for (auto &kvp : res)
      {
        std::string payload = kvp.value("data", "");
        int since = kvp.value("since", 0);
        std::string streamer = kvp.value("streamerInfo", "");
        // Register everything on the file system.
        storePayloadDump(tag, since, payload, payloadFormat,
                         objectType, compressionType, version, streamer);
      }
    } // end of try
    catch (...)
    {
      throw CrestException("ERROR in CrestFsClient::storeData cannot store the data in a file");
    } // end of catch
    flush();
  }

storePayloadDump()

void Crest::CrestFsClient::storePayloadDump ( const std::string &  tag, uint64_t  since, const std::string &  js, const std::string &  payloadFormat, const std::string &  objectType, const std::string &  compressionType, const std::string &  version, const std::string &  streamerInfo  )

private

This auxiliary method stores a single payload (with since time) on the file system.

Parameters

tag	- tag name.
since	- since parameter,
js	- a string with a payload or file (the path and the file name) with payload.
payloadFormat	- payload format [FILE | JSON].
objectType	- object type.
compressionType	- compression type.
version	- version.
endTime	- end time, if endtime = 0, the server does not use this parameter in the internal check.

Definition at line 728 of file CrestApiFs.cxx.

  {
 
    std::ofstream outFile;
 
    std::string hashCode;
    std::string payloadLocalFile;
 
    // payload file:
    if (payloadFormat == "JSON")
    {
      hashCode = getHash(js);
    }
    else
    {
 
      int found_dots = js.find_first_of(':');
      int word_size = js.size();
      payloadLocalFile = js.substr(found_dots + 3, word_size);
 
      hashCode = getHashForFile(payloadLocalFile);
    }
 
    std::string workDir = m_data_folder;
    workDir += '/';
    workDir += getFirstLetters(hashCode);
    if (!std::filesystem::exists(std::filesystem::path(workDir)))
    {
      std::filesystem::create_directory(std::filesystem::path(workDir));
    }
    workDir += '/';
    workDir += hashCode;
    if (!std::filesystem::exists(std::filesystem::path(workDir)))
    {
      std::filesystem::create_directory(std::filesystem::path(workDir));
    }
    std::string tagFile = workDir + "/payload.json";
 
    if (payloadFormat == "JSON")
    {
      outFile.open(tagFile);
      outFile << js;
      outFile.close();
    }
    else
    {
      try
      {
        std::filesystem::copy_file(payloadLocalFile, tagFile);
      }
      catch (std::filesystem::filesystem_error &e)
      {
        throw CrestException("ERROR in CrestFsClient::storePayloadDump cannot not save payload file: " + tagFile + e.what());
      }
    }
 
    // Define the meta info for the payload:
    nlohmann::json jsn =
        {
            {"hash", hashCode},
            {"checkSum", "SHA-256"},
            {"objectType", objectType},
            {"version", version},
            {"size", js.size()},
            {"streamerInfo", streamerInfo},
            {"compressionType", compressionType},
            {"insertionTime", getDateAndTime()}};
 
    // payload meta info file:
    std::string metaFile = workDir + "/meta.json";
 
    outFile.open(metaFile);
    outFile << jsn.dump();
    outFile.close();
 
    // check if data exists
 
    if (m_data.find(tag) == m_data.end())
    {
      try
      {
        nlohmann::json jsi = findAllIovs(tag);
        m_data.insert(std::pair<std::string, nlohmann::json>(tag, jsi));
      }
      catch (...)
      {
        try
        { // tag exists, but there are no IOVs
          nlohmann::json tagJS = findTag(tag).to_json();
          nlohmann::json jsFree = nlohmann::json::array({});
          m_data.insert(std::pair<std::string, nlohmann::json>(tag, jsFree));
        }
        catch (...)
        {
          throw CrestException(
              "ERROR in CrestFsClient::storePayloadDump cannot get data for tag \"" + tag + "\" from file storage.");
        }
      }
    }
 
    std::map<std::string, nlohmann::json>::iterator it = m_data.find(tag);
    if (it != m_data.end())
    {
      std::string link = hashCode;
      nlohmann::json iovs = it->second;
      nlohmann::json obj(nlohmann::json::value_t::object);
      obj["tagName"] = tag;
      obj["since"] = since;
      obj["insertionTime"] = getDateAndTime();
      obj["payloadHash"] = link;
      iovs.push_back(obj);
      m_data[it->first] = iovs;
    }
  }

updateTagMeta()

void Crest::CrestFsClient::updateTagMeta ( TagMetaDto &  tag )

overridevirtual

This method updates a tag meta info on the file storage.

Parameters

tag	- tag meta info as TagMetaDto.

Implements Crest::CrestApiBase.

Definition at line 401 of file CrestApiFs.cxx.

  {
    checkFsException("CrestFsClient::updateTagMeta");
  }

Member Data Documentation

m_currentTag

std::string Crest::CrestFsClient::m_currentTag {}

private

Definition at line 58 of file CrestApiFs.h.

m_data

std::map<std::string, nlohmann::json> Crest::CrestFsClient::m_data {}

private

Definition at line 36 of file CrestApiFs.h.

m_data_folder

std::string Crest::CrestFsClient::m_data_folder {}

private

Definition at line 35 of file CrestApiFs.h.

m_isRewrite

bool Crest::CrestFsClient::m_isRewrite {}

private

Definition at line 37 of file CrestApiFs.h.

m_root_folder

std::string Crest::CrestFsClient::m_root_folder {}

private

Definition at line 34 of file CrestApiFs.h.

s_CREST_CLIENT_VERSION

const std::string Crest::CrestApiBase::s_CREST_CLIENT_VERSION = "5.0"

inlinestaticprivateinherited

Definition at line 36 of file CrestApiBase.h.

s_FS_DATA_PATH

const std::string Crest::CrestFsClient::s_FS_DATA_PATH = "/data"

inlinestaticprivate

Definition at line 43 of file CrestApiFs.h.

s_FS_GLOBALTAG_FILE

const std::string Crest::CrestFsClient::s_FS_GLOBALTAG_FILE = "/globaltag.json"

inlinestaticprivate

Definition at line 52 of file CrestApiFs.h.

s_FS_GLOBALTAG_PATH

const std::string Crest::CrestFsClient::s_FS_GLOBALTAG_PATH = "/globaltags"

inlinestaticprivate

Definition at line 42 of file CrestApiFs.h.

s_FS_IOV_FILE

const std::string Crest::CrestFsClient::s_FS_IOV_FILE = "/iovs.json"

inlinestaticprivate

Definition at line 46 of file CrestApiFs.h.

s_FS_MAP_FILE

const std::string Crest::CrestFsClient::s_FS_MAP_FILE = "/maps.json"

inlinestaticprivate

Definition at line 53 of file CrestApiFs.h.

s_FS_META_FILE

const std::string Crest::CrestFsClient::s_FS_META_FILE = "/meta.json"

inlinestaticprivate

Definition at line 49 of file CrestApiFs.h.

s_FS_PALOAD_FILE

const std::string Crest::CrestFsClient::s_FS_PALOAD_FILE = "/payload.json"

inlinestaticprivate

Definition at line 50 of file CrestApiFs.h.

s_FS_PATH

const std::string Crest::CrestFsClient::s_FS_PATH = ""

inlinestaticprivate

Definition at line 55 of file CrestApiFs.h.

s_FS_PREFIX_LENGTH

const int Crest::CrestFsClient::s_FS_PREFIX_LENGTH = 3

inlinestaticprivate

Definition at line 57 of file CrestApiFs.h.

s_FS_TAG_FILE

const std::string Crest::CrestFsClient::s_FS_TAG_FILE = "/tag.json"

inlinestaticprivate

Definition at line 45 of file CrestApiFs.h.

s_FS_TAG_PATH

const std::string Crest::CrestFsClient::s_FS_TAG_PATH = "/tags"

inlinestaticprivate

Definition at line 41 of file CrestApiFs.h.

s_FS_TAGMETAINFO_FILE

const std::string Crest::CrestFsClient::s_FS_TAGMETAINFO_FILE = "/tagmetainfo.json"

inlinestaticprivate

Definition at line 47 of file CrestApiFs.h.

---

The documentation for this class was generated from the following files:

• CrestApiFs.h
• CrestApiFs.cxx