Crest::CrestClientExt Class Reference

#include <CrestApiExt.h>

Inheritance diagram for Crest::CrestClientExt:

Collaboration diagram for Crest::CrestClientExt:

Public Member Functions
	CrestClientExt (const std::string &_host, const std::string &_port, bool _check_version=s_CREST_CLIENT_CHECK)
	CrestClientExt (const std::string &url, bool check_version=s_CREST_CLIENT_CHECK)
	BOOST_PARAMETER_MEMBER_FUNCTION ((GlobalTagSetDto), listGlobalTagsParams, tag,(required)(optional(name,(std::string), "")(size,(int), 1000)(page,(int), 0)(sort,(std::string), "name:ASC")))
	This method returns the global tag list. More...
	BOOST_PARAMETER_MEMBER_FUNCTION ((TagSetDto), listTagsParams, tag,(required)(optional(name,(std::string), "")(size,(int), 1000)(page,(int), 0)(sort,(std::string), "name:ASC")))
	This method returns the tag list. More...
void	checkCrestVersion ()
	This method is a CREST version test. More...
void	createGlobalTag (GlobalTagDto &globalTag) override
	This method creates a global tag on CREST server. More...
GlobalTagDto	findGlobalTag (const std::string &name) override
	This method finds a global tag by name on the CREST server. More...
GlobalTagSetDto	listGlobalTags (const std::string &name, int size, int page, const std::string &sort) override
	This method finds the global tags on the CREST server. More...
void	removeGlobalTag (const std::string &name) override
	This method removes a global tag on the CREST server. More...
void	createTag (TagDto &tag) override
	This method creates a tag on the CREST server. More...
TagDto	findTag (const std::string &name) override
	This method finds a tag by the name on the CREST server. More...
TagSetDto	listTags (const std::string &name, int size, int page, const std::string &sort) override
	This method returns the tag list as TagSetDto from the CREST server. More...
void	removeTag (const std::string &name) override
	This method removes a tag from the CREST server. 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 CREST server. More...
void	updateTagMeta (TagMetaDto &tag) override
	This method updates a tag meta info on the CREST server. More...
TagMetaDto	findTagMeta (const std::string &name) override
	This method reads a tag meta info by the tag name from the CREST server. More...
void	createGlobalTagMap (GlobalTagMapDto &globalTagMap) override
	This method creates a global tag map on the CREST server. 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 CREST server. 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 on the CREST server. 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 on the CREST server. 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 on CREST server. 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 CREST server. More...
std::string	getPayload (const std::string &hash) override
	This method finds a payload resource associated to the hash on the CREST server. More...
PayloadDto	getPayloadMeta (const std::string &hash) override
	This method finds a payload meta info for the hash on the CREST server. More...

Static Public Attributes
static const bool	s_CREST_CLIENT_CHECK = false

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
std::string	makeUrl (const std::string &address) const
nlohmann::json	getMgmtInfo ()
	This is an auxiliary method to read the CREST Server properties. More...
std::string	getCrestVersion () override
	This method returns the full CREST Server version. More...
int	getMajorVersion (std::string &str)
	This is an auxiliary method to extract a major version number from full version string. More...
nlohmann::json	getJson (const std::string &str, const char *method) const
	Auxiliary method to convert string in to JSON object. More...
std::string	parseXMLOutput (const std::string_view xmlBuffer) const
	This method removes all XML/HTML tags from a string. More...
std::string	removeCR (const std::string &str) const
	This method removes all end of line and carriage return symbols from a string. More...
void	checkHash (const std::string &hash, const std::string &str, const char *method_name)
	This checks the hash of payload from IOV (hash) with the hash calculated for the payload in the std::string (str) (It is an auxiliary method to check the payload.) More...

Private Attributes
std::string	m_PATH = DEFAULT_CREST_API_VERSION
std::string	m_host
std::string	m_port
std::string	m_prefix = "http://"
Crest::CrestRequest	m_request = Crest::CrestRequest()

Static Private Attributes
static const std::string	s_TAG_PATH = "/tags"
static const std::string	s_ADMIN_PATH = "/admin"
static const std::string	s_IOV_PATH = "/iovs"
static const std::string	s_IOV_SIZE_PATH = "/size"
static const std::string	s_GLOBALTAG_PATH = "/globaltags"
static const std::string	s_GLOBALTAG_MAP_PATH = "/globaltagmaps"
static const std::string	s_PAYLOAD_PATH = "/payloads"
static const std::string	s_MONITORING_PAYLOAD_PATH = "/monitoring/payloads"
static const std::string	s_META_PATH = "/meta"
static const std::string	s_DATA_PATH = "/data"
static const std::string	s_FOLDER_PATH = "/folders"
static const std::string	s_RUNINFO_PATH = "/runinfo"
static const std::string	s_RUNINFO_LIST_PATH = "/list"
static const std::string	s_METHOD_IOVS = "IOVS"
static const std::string	s_METHOD_GROUPS = "GROUPS"
static const std::string	s_MGMT_PATH = "/mgmt"
static const std::string	s_MGMT_INFO_PATH = "/info"
static const std::string	s_CREST_CLIENT_VERSION = "5.0"
static const std::string	s_MGMT_INFO_PATH_2 = "/actuator/info"

Detailed Description

Definition at line 28 of file CrestApiExt.h.

Constructor & Destructor Documentation

CrestClientExt() [1/2]

Crest::CrestClientExt::CrestClientExt ( const std::string &  _host, const std::string &  _port, bool  _check_version = s_CREST_CLIENT_CHECK  )

inline

Definition at line 30 of file CrestApiExt.h.

: CrestClient(_host, _port, _check_version) {}

CrestClientExt() [2/2]

Crest::CrestClientExt::CrestClientExt ( const std::string &  url, bool  check_version = s_CREST_CLIENT_CHECK  )

inline

Definition at line 31 of file CrestApiExt.h.

: CrestClient(url, check_version) {}

Member Function Documentation

BOOST_PARAMETER_MEMBER_FUNCTION() [1/2]

Crest::CrestClientExt::BOOST_PARAMETER_MEMBER_FUNCTION ( (GlobalTagSetDto)  , listGlobalTagsParams  , tag  , (required)(optional(name,(std::string), "")(size,(int), 1000)(page,(int), 0)(sort,(std::string), "name:ASC"))    )

inline

This method returns the global tag list.

It has boost parameters, all of them are optional.

Parameters

_name	- global tag name pattern, optional parameter,
_size	- page size, a number of tags per a page, optional parameter, default value is 1000,
_page	- page number optional parameter, default value is 0,
_sort	- sorting order, default value is "name:ASC". If you dont use the optional parameter names, you have to use the same parameter order. Example: nlohmann::json list1 = myCrestClient.listGlobalTagsParams(); nlohmann::json list2 = myCrestClient.listGlobalTagsParams("",3,5); nlohmann::json list2 = myCrestClient.listGlobalTagsParams(_page=3,_size=5);

nlohmann::json listGlobalTagsParams(std::string _name, int _size, int _page);

Definition at line 51 of file CrestApiExt.h.

                                  :ASC")
      )
      ) {
      return listGlobalTags(name, size, page, sort);
    }

BOOST_PARAMETER_MEMBER_FUNCTION() [2/2]

Crest::CrestClientExt::BOOST_PARAMETER_MEMBER_FUNCTION ( (TagSetDto)  , listTagsParams  , tag  , (required)(optional(name,(std::string), "")(size,(int), 1000)(page,(int), 0)(sort,(std::string), "name:ASC"))    )

inline

This method returns the tag list.

It has boost parameters, all of them are optional. (This method is an analogue of the list_tags method in Python)

Parameters

_name	- tag name pattern, optional parameter,
_size	- page size, a number of tags per a page, optional parameter, default value is 1000,
_page	- page number optional parameter, default value is 0,
_sort	- sorting order, default value is "name:ASC". If you dont use the optional parameter names, you have to use the same parameter order. Example: nlohmann::json list1 = myCrestClient.listTagsParams(); nlohmann::json list2 = myCrestClient.listTagsParams("",3,5); nlohmann::json list2 = myCrestClient.listTagsParams(_page=3,_size=5);

nlohmann::json listTagsParams(std::string _name, int _size, int _page);

Definition at line 84 of file CrestApiExt.h.

                                  :ASC")
      )
      ) {
      return listTags(name, size, page, sort);
    }

checkCrestVersion()

void Crest::CrestClient::checkCrestVersion ( )

inherited

This method is a CREST version test.

It checks if the major CREST server is equal to the major CrestApi vesrion. If the versions are different an error is thrown.

Exceptions

std::runtime_error

- error, if the versions are different.

Definition at line 259 of file CrestApi.cxx.

    {
        std::string client = getClientVersion();
        std::string server = getCrestVersion();
 
        int clientVersion = getMajorVersion(client);
        int serverVersion = getMajorVersion(server);
 
        if (clientVersion != serverVersion)
        {
      throw CrestException("ERROR in CrestClient::checkCrestVersion: CrestApi version \"" + client + "\" does not correspond to the server version \"" + server + "\".");
        }
    }

checkHash()

void Crest::CrestClient::checkHash ( const std::string &  hash, const std::string &  str, const char *  method_name  )

privateinherited

This checks the hash of payload from IOV (hash) with the hash calculated for the payload in the std::string (str) (It is an auxiliary method to check the payload.)

Parameters

hash	- the hash from an IOV.
str	- the payload in std::string.

Definition at line 795 of file CrestApi.cxx.

    {
      std::string calculatedHash = getHash(str);
      if (hash != calculatedHash) {
    throw CrestException("ERROR in " + (std::string)method_name + ": payload is corrupted.");
      }
      return;
    }

createGlobalTag()

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

overridevirtualinherited

This method creates a global tag on CREST server.

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 284 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::createGlobalTag";
 
        std::string current_path = m_PATH;
        current_path += s_GLOBALTAG_PATH;
        std::string retv;
        nlohmann::json js = dto.to_json();
        retv = m_request.performRequest(current_path, Action::POST, js, method_name);
    }

createGlobalTagMap()

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

overridevirtualinherited

This method creates a global tag map on the CREST server.

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 554 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::createGlobalTagMap";
 
        std::string current_path = m_PATH;
        current_path += s_GLOBALTAG_MAP_PATH;
        std::string retv;
        nlohmann::json js = dto.to_json();
        retv = m_request.performRequest(current_path, Action::POST, js, method_name);
    }

createTag()

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

overridevirtualinherited

This method creates a tag on the CREST server.

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 374 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::createTag";
 
        std::string current_path = m_PATH;
        current_path += s_TAG_PATH;
        std::string retv;
        nlohmann::json js = dto.to_json();
        retv = m_request.performRequest(current_path, Action::POST, js, method_name);
    }

createTagMeta()

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

overridevirtualinherited

This method creates a tag meta info on the CREST server.

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 464 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::createTagMeta";
 
        std::string current_path = m_PATH;
        current_path += s_TAG_PATH;
        current_path += '/';
        current_path += dto.tagName;
        current_path += s_META_PATH;
 
        std::string retv;
        nlohmann::json js = dto.to_json();
        retv = m_request.performRequest(current_path, Action::POST, js, method_name);
    }

findGlobalTag()

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

overridevirtualinherited

This method finds a global tag by name on the CREST server.

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 295 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::findGlobalTag";
 
        std::string current_path = m_PATH;
        current_path += s_GLOBALTAG_PATH;
        current_path += '/';
        current_path += name;
        std::string retv;
 
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
 
        GlobalTagSetDto dto = GlobalTagSetDto::from_json(response);
        std::vector<GlobalTagDto> v = dto.resources;
        // Only one element is expected:
        return v[0];
    }

findGlobalTagMap()

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

overridevirtualinherited

This method searches for tag mappings using the global tag name or tag name on the CREST server.

(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 565 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::findGlobalTagMap";
 
        std::string current_path = m_PATH;
        current_path += s_GLOBALTAG_MAP_PATH;
        current_path += '/';
        current_path += name;
        std::string headers_params = "";
 
        if (xCrestMapMode != "")
        {
            headers_params += "X-Crest-MapMode: ";
            headers_params += xCrestMapMode;
        }
        else
        {
            headers_params += "X-Crest-MapMode: ";
            headers_params += "Trace";
        }
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name, headers_params);
        nlohmann::json response = getJson(retv, method_name);
        GlobalTagMapSetDto dto = GlobalTagMapSetDto::from_json(response);
 
        return dto;
    }

findTag()

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

overridevirtualinherited

This method finds a tag by the name on the CREST server.

(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 386 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::findTag";
 
        std::string current_path = m_PATH;
        current_path += s_TAG_PATH;
        current_path += '/';
        current_path += name;
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
        TagSetDto dto = TagSetDto::from_json(response);
 
        std::vector<TagDto> v = dto.resources;
        // Only one element is expected:
        return v[0];
    }

findTagMeta()

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

overridevirtualinherited

This method reads a tag meta info by the tag name from the CREST server.

Parameters

name	- tag name

Returns

tag meta info as a TagMetaDto.

Implements Crest::CrestApiBase.

Definition at line 494 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::findTagMeta";
 
        std::string current_path = m_PATH;
        current_path += s_TAG_PATH;
        current_path += '/';
        current_path += name;
        current_path += s_META_PATH;
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
 
        TagMetaSetDto dto = TagMetaSetDto::from_json(response);
        std::vector<TagMetaDto> v = dto.resources;
        // Only one element is expected:
        return v[0];
    }

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::CrestClient::getCrestVersion ( )

overrideprivatevirtualinherited

This method returns the full CREST Server version.

Returns

CREST server version.

Implements Crest::CrestApiBase.

Definition at line 214 of file CrestApi.cxx.

    {
 
        std::string version = "";
        nlohmann::json buildInfo;
        nlohmann::json info = getMgmtInfo();
        // The CREST Server response has the following structure:
        // { "build": { "artifact": "crestdb", "name": "crest", "version": "4.0", "group": "hep.crest"} }
        try
        {
            buildInfo = info["build"];
            version = buildInfo["version"];
        }
        catch (const std::exception &e)
        {
            throw CrestException("ERROR in CrestClient::getCrestVersion: " + to_string(info) + " does not contain version info.");
        }
        return version;
    }

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;
  }

getJson()

nlohmann::json Crest::CrestClient::getJson ( const std::string &  str, const char *  method  ) const

privateinherited

Auxiliary method to convert string in to JSON object.

CrestClient::getJson method is used to convert the string to the json object.

Parameters

str	- string (std::string)
method	- method name, which calls this method. This parameter is used to throw an error exception.

Returns

- JSON object as nlohmann::json

Parameters

str	- string to be converted to the json object.
method	- name of the method which calls this method.

Returns

json object.

Definition at line 169 of file CrestApi.cxx.

    {
        nlohmann::json js = nullptr;
        try
        {
            js = nlohmann::json::parse(str);
        }
        catch (nlohmann::json::parse_error &e)
        {
            if (method == nullptr || *method == '\0')
            {
                // method name is undefined
 
                std::string wh = e.what();
                throw CrestException("ERROR in JSON conversion: " + wh + " | In string: " + str);
            }
            else
            {
                std::string str2 = parseXMLOutput(str); // to remove HTML tags use this function
                std::string str3 = removeCR(str2);      // to remove carridge return
                throw CrestException("ERROR in " + std::string(method) + " | CREST Server response : " + str3);
            }
        }
        catch (const std::exception &e)
        {
            throw CrestException("ERROR in CrestClient::" + (std::string)method + ": " + e.what());
        }
        return js;
    }

getMajorVersion()

int Crest::CrestClient::getMajorVersion ( std::string &  str )

privateinherited

This is an auxiliary method to extract a major version number from full version string.

Returns

major version number.

Definition at line 235 of file CrestApi.cxx.

    {
        int v = -1;
        int n = str.find('.');
 
        if (n < 1)
        {
            throw CrestException("ERROR in CrestClient::getMajorVersion: string \"" + str + "\" does not contain major version.");
        }
 
        std::string vers = str.substr(0, n);
 
        try
        {
            v = std::stoi(str);
        }
        catch (const std::exception &e)
        {
            throw CrestException("ERROR in CrestClient::getMajorVersion: string \"" + str + "\" does not contain major version.");
        }
 
        return v;
    }

getMgmtInfo()

nlohmann::json Crest::CrestClient::getMgmtInfo ( )

privateinherited

This is an auxiliary method to read the CREST Server properties.

Returns

JSON with CREST server properties.

Example:
 {
  "build":{
    "artifact":"crestdb",
    "name":"crestdb",
    "time":"2023-12-02T15:21:57.045Z",
    "version":"4.2.1",
    "group":"hep.crest"
  }
 }

Definition at line 199 of file CrestApi.cxx.

    {
        const char *method_name = "getMgmtInfo";
 
        std::string current_path = s_MGMT_PATH + s_MGMT_INFO_PATH;
        std::string retv;
        nlohmann::json js = nullptr;
 
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
 
        nlohmann::json respond = getJson(retv, method_name);
 
        return respond;
    }

getPayload()

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

overridevirtualinherited

This method finds a payload resource associated to the hash on the CREST server.

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 760 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::getPayload";
 
        std::string current_path = m_PATH;
        current_path += s_PAYLOAD_PATH;
        current_path += "/data?format=BLOB&hash=";
        current_path += hash;
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
    checkHash(hash, retv, method_name);
        return retv;
    }

getPayloadMeta()

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

overridevirtualinherited

This method finds a payload meta info for the hash on the CREST server.

(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 775 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::getPayloadMeta";
 
        std::string current_path = m_PATH;
        current_path += s_PAYLOAD_PATH;
        current_path += '/';
        current_path += hash;
        current_path += "?format=META";
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
 
        PayloadSetDto dto = PayloadSetDto::from_json(response);
        std::vector<PayloadDto> v = dto.resources;
        // Only one element is expected:
        return v[0];
    }

getSize()

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

overridevirtualinherited

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 515 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::getSize";
 
        std::string current_path = m_PATH;
        current_path += s_IOV_PATH;
        current_path += s_IOV_SIZE_PATH;
        current_path += "?tagname=";
        current_path += tagname;
 
        std::string retv;
 
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json respond = getJson(retv, method_name);
 
        auto res = respond.find("resources");
        nlohmann::json r;
 
        if (res != respond.end())
        {
            r = respond["resources"][0];
        }
 
        int result = 0;
        if (r.find("niovs") != r.end())
        {
            result = r["niovs"];
        }
        else
        {
            throw CrestException("ERROR in CrestClient::getSize CREST Server JSON response has no \"size\" key.");
        }
 
        return result;
    }

listGlobalTags()

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

overridevirtualinherited

This method finds the global tags on the CREST server.

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 315 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::listGlobalTags";
 
        std::string current_path = m_PATH;
        current_path += s_GLOBALTAG_PATH;
        current_path += '?';
        if (name != "")
        {
            current_path += "name=";
            current_path += name;
            current_path += '&';
        }
        if (size != -1)
        {
            current_path += "size=";
            current_path += std::to_string(size);
            current_path += '&';
        }
        if (page != -1)
        {
            current_path += "page=";
            current_path += std::to_string(page);
            current_path += '&';
        }
        if (sort != "")
        {
            current_path += "sort=";
            current_path += sort;
            current_path += '&';
        }
        std::string retv;
 
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
 
        GlobalTagSetDto dto = GlobalTagSetDto::from_json(response);
 
        return dto;
    }

listTags()

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

overridevirtualinherited

This method returns the tag list as TagSetDto from the CREST server.

(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 405 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::listTags";
 
        std::string current_path = m_PATH;
        current_path += s_TAG_PATH;
        current_path += '?';
        if (name != "")
        {
            current_path += "name=";
            current_path += name;
            current_path += '&';
        }
        if (size != -1)
        {
            current_path += "size=";
            current_path += std::to_string(size);
            current_path += '&';
        }
        if (page != -1)
        {
            current_path += "page=";
            current_path += std::to_string(page);
            current_path += '&';
        }
        if (sort != "")
        {
            current_path += "sort=";
            current_path += sort;
            current_path += '&';
        }
        std::string retv;
 
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
 
        TagSetDto dto = TagSetDto::from_json(response);
 
        return dto;
    }

makeUrl()

std::string Crest::CrestClient::makeUrl ( const std::string &  address ) const

privateinherited

Definition at line 273 of file CrestApi.cxx.

    {
        std::string str = m_prefix;
        str += m_host;
        str += ':';
        str += m_port;
        str += address;
        return str;
    }

parseXMLOutput()

std::string Crest::CrestClient::parseXMLOutput ( const std::string_view  xmlBuffer ) const

privateinherited

This method removes all XML/HTML tags from a string.

(It is an auxiliary method to clear the CREST Server response.)

Parameters

xmlBuffer

- the text (a std::string ) to be cleared.

Definition at line 121 of file CrestApi.cxx.

    {
        bool copy = true;
 
        std::string plainString = "";
 
        // remove all xml tags
        for (long unsigned int i = 0; i < xmlBuffer.length(); i++)
        {
            char convertc = xmlBuffer[i];
 
            if (convertc == '<')
                copy = false;
            else if (convertc == '>')
            {
                copy = true;
                continue;
            }
 
            if (copy)
                plainString += convertc;
        }
 
        return plainString;
    }

removeCR()

std::string Crest::CrestClient::removeCR ( const std::string &  str ) const

privateinherited

This method removes all end of line and carriage return symbols from a string.

(It is an auxiliary method to clear the CREST Server response.)

Parameters

str	- the text (a std::string ) to be cleared.

Definition at line 149 of file CrestApi.cxx.

    {
        std::string str2 = str;
        std::replace(str2.begin(), str2.end(), '\n', '|');
        char needle = '\r';
        size_t pos;
        while ((pos = str2.find(needle)) != str2.npos)
        {
            str2.erase(pos, 1);
        }
        return str2;
    }

removeGlobalTag()

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

overridevirtualinherited

This method removes a global tag on the CREST server.

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

Parameters

name	- global tag name

Implements Crest::CrestApiBase.

Definition at line 358 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::removeGlobalTag";
 
        std::string current_path = m_PATH;
        current_path += s_ADMIN_PATH;
        current_path += s_GLOBALTAG_PATH;
        current_path += '/';
        current_path += name;
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::DELETE, js, method_name);
    }

removeGlobalTagMap()

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

overridevirtualinherited

This method removes a global tag map on the CREST server.

Parameters

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

Implements Crest::CrestApiBase.

Definition at line 594 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::removeGlobalTagMap";
 
        std::string current_path = m_PATH;
        current_path += s_GLOBALTAG_MAP_PATH;
        current_path += '/';
        current_path += name;
        current_path += '?';
        if (tagname != "")
        {
            current_path += "tagname=";
            current_path += tagname;
            current_path += '&';
        }
        if (record != "")
        {
            current_path += "record=";
            current_path += record;
            current_path += '&';
        }
        if (label != "")
        {
            current_path += "label=";
            current_path += label;
            current_path += '&';
        }
 
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::DELETE, js, method_name);
    }

removeTag()

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

overridevirtualinherited

This method removes a tag from the CREST server.

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

Parameters

tagName

- tag name

Implements Crest::CrestApiBase.

Definition at line 448 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::removeTag";
 
        std::string current_path = m_PATH;
        current_path += s_ADMIN_PATH;
        current_path += s_TAG_PATH;
        current_path += '/';
        current_path += name;
        std::string retv;
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::DELETE, js, method_name);
    }

selectGroups()

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

overridevirtualinherited

This method returns IOV groups for a given tagname on CREST server.

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 674 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::selectGroups";
 
        std::string current_path = m_PATH;
        current_path += s_IOV_PATH;
 
        current_path += "?method=";
        current_path += s_METHOD_GROUPS;
        current_path += "&tagname=";
 
        current_path += name;
        current_path += "&snapshot=";
        current_path += std::to_string(snapshot);
 
    //
        current_path += "&size=";
        current_path += std::to_string(size);
        current_path += "&page=";
        current_path += std::to_string(page);
        current_path += "&sort=";
        current_path += sort;
    //
    
        std::string retv;
 
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
 
        IovSetDto dto = IovSetDto::from_json(response);
 
        return dto;
    }

selectIovs()

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

overridevirtualinherited

This method selects IOVs for a given tagname on the CREST server.

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 629 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::selectIovs";
 
        std::string current_path = m_PATH;
        current_path += s_IOV_PATH;
 
        current_path += "?method=";
        current_path += s_METHOD_IOVS;
        current_path += "&tagname=";
 
        current_path += name;
        current_path += "&since=";
        current_path += std::to_string(since);
        current_path += "&until=";
        if (until == static_cast<uint64_t>(-1))
        {
            current_path += "INF";
        }
        else
        {
            current_path += std::to_string(until);
        }
        current_path += "&snapshot=";
        current_path += std::to_string(snapshot);
    //
        current_path += "&size=";
        current_path += std::to_string(size);
        current_path += "&page=";
        current_path += std::to_string(page);
        current_path += "&sort=";
        current_path += sort;
    //
 
        std::string retv;
 
        nlohmann::json js = nullptr;
        retv = m_request.performRequest(current_path, Action::GET, js, method_name);
        nlohmann::json response = getJson(retv, method_name);
 
        IovSetDto dto = IovSetDto::from_json(response);
 
        return dto;
    }

storeData()

void Crest::CrestClient::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  )

overridevirtualinherited

This method stores several payloads in batch mode on the CREST server.

(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 711 of file CrestApi.cxx.

    {
 
        std::string current_path = m_PATH;
        current_path += s_PAYLOAD_PATH;
        std::vector<std::string> files;
        std::string retv;
        nlohmann::json js = storeSetJson.to_json();
        if (payloadFormat == "JSON")
        {
            retv = m_request.uploadPayload(current_path, tag, endTime, js, objectType, compressionType, version, files);
        }
        else
        {
            // Assumes the data content in the JSON is just a file path.
            nlohmann::json resources = nullptr;
 
            auto subjectIdIter1 = js.find("resources");
            if (subjectIdIter1 != js.end())
            {
                resources = js["resources"];
            }
            int partN = resources.size();
            for (int i = 0; i < partN; i++)
            {
                nlohmann::json element = resources[i];
                std::string file_param;
 
                auto subjectIdIter1 = element.find("data");
                if (subjectIdIter1 != element.end())
                {
                    file_param = element["data"];
                }
                //
                int found_dots = file_param.find_first_of(':');
                int word_size = file_param.size();
                std::string data_file = file_param.substr(found_dots + 3, word_size);
                files.push_back(data_file);
            }
            retv = m_request.uploadPayload(current_path, tag, endTime, js, objectType, compressionType, version, files);
        }
    }

updateTagMeta()

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

overridevirtualinherited

This method updates a tag meta info on the CREST server.

Parameters

tag	- tag meta info as TagMetaDto.

Implements Crest::CrestApiBase.

Definition at line 479 of file CrestApi.cxx.

    {
        const char *method_name = "CrestClient::updateTagMeta";
 
        std::string current_path = m_PATH;
        current_path += s_TAG_PATH;
        current_path += '/';
        current_path += dto.tagName;
        current_path += s_META_PATH;
 
        std::string retv;
        nlohmann::json js = dto.to_json();
        retv = m_request.performRequest(current_path, Action::PUT, js, method_name);
    }

Member Data Documentation

m_host

std::string Crest::CrestClient::m_host

privateinherited

Definition at line 67 of file CrestApi.h.

m_PATH

std::string Crest::CrestClient::m_PATH = DEFAULT_CREST_API_VERSION

privateinherited

Definition at line 37 of file CrestApi.h.

m_port

std::string Crest::CrestClient::m_port

privateinherited

Definition at line 68 of file CrestApi.h.

m_prefix

std::string Crest::CrestClient::m_prefix = "http://"

privateinherited

Definition at line 69 of file CrestApi.h.

m_request

Crest::CrestRequest Crest::CrestClient::m_request = Crest::CrestRequest()

privateinherited

Definition at line 71 of file CrestApi.h.

s_ADMIN_PATH

const std::string Crest::CrestClient::s_ADMIN_PATH = "/admin"

inlinestaticprivateinherited

Definition at line 40 of file CrestApi.h.

s_CREST_CLIENT_CHECK

const bool Crest::CrestClient::s_CREST_CLIENT_CHECK = false

inlinestaticinherited

Definition at line 168 of file CrestApi.h.

s_CREST_CLIENT_VERSION

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

inlinestaticprivateinherited

Definition at line 62 of file CrestApi.h.

s_DATA_PATH

const std::string Crest::CrestClient::s_DATA_PATH = "/data"

inlinestaticprivateinherited

Definition at line 50 of file CrestApi.h.

s_FOLDER_PATH

const std::string Crest::CrestClient::s_FOLDER_PATH = "/folders"

inlinestaticprivateinherited

Definition at line 52 of file CrestApi.h.

s_GLOBALTAG_MAP_PATH

const std::string Crest::CrestClient::s_GLOBALTAG_MAP_PATH = "/globaltagmaps"

inlinestaticprivateinherited

Definition at line 46 of file CrestApi.h.

s_GLOBALTAG_PATH

const std::string Crest::CrestClient::s_GLOBALTAG_PATH = "/globaltags"

inlinestaticprivateinherited

Definition at line 45 of file CrestApi.h.

s_IOV_PATH

const std::string Crest::CrestClient::s_IOV_PATH = "/iovs"

inlinestaticprivateinherited

Definition at line 41 of file CrestApi.h.

s_IOV_SIZE_PATH

const std::string Crest::CrestClient::s_IOV_SIZE_PATH = "/size"

inlinestaticprivateinherited

Definition at line 43 of file CrestApi.h.

s_META_PATH

const std::string Crest::CrestClient::s_META_PATH = "/meta"

inlinestaticprivateinherited

Definition at line 49 of file CrestApi.h.

s_METHOD_GROUPS

const std::string Crest::CrestClient::s_METHOD_GROUPS = "GROUPS"

inlinestaticprivateinherited

Definition at line 57 of file CrestApi.h.

s_METHOD_IOVS

const std::string Crest::CrestClient::s_METHOD_IOVS = "IOVS"

inlinestaticprivateinherited

Definition at line 56 of file CrestApi.h.

s_MGMT_INFO_PATH

const std::string Crest::CrestClient::s_MGMT_INFO_PATH = "/info"

inlinestaticprivateinherited

Definition at line 61 of file CrestApi.h.

s_MGMT_INFO_PATH_2

const std::string Crest::CrestClient::s_MGMT_INFO_PATH_2 = "/actuator/info"

inlinestaticprivateinherited

Definition at line 63 of file CrestApi.h.

s_MGMT_PATH

const std::string Crest::CrestClient::s_MGMT_PATH = "/mgmt"

inlinestaticprivateinherited

Definition at line 60 of file CrestApi.h.

s_MONITORING_PAYLOAD_PATH

const std::string Crest::CrestClient::s_MONITORING_PAYLOAD_PATH = "/monitoring/payloads"

inlinestaticprivateinherited

Definition at line 48 of file CrestApi.h.

s_PAYLOAD_PATH

const std::string Crest::CrestClient::s_PAYLOAD_PATH = "/payloads"

inlinestaticprivateinherited

Definition at line 47 of file CrestApi.h.

s_RUNINFO_LIST_PATH

const std::string Crest::CrestClient::s_RUNINFO_LIST_PATH = "/list"

inlinestaticprivateinherited

Definition at line 54 of file CrestApi.h.

s_RUNINFO_PATH

const std::string Crest::CrestClient::s_RUNINFO_PATH = "/runinfo"

inlinestaticprivateinherited

Definition at line 53 of file CrestApi.h.

s_TAG_PATH

const std::string Crest::CrestClient::s_TAG_PATH = "/tags"

inlinestaticprivateinherited

Definition at line 39 of file CrestApi.h.

---

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

• CrestApiExt.h