Crest::CrestClient Class Reference

#include <CrestApi.h>

Inheritance diagram for Crest::CrestClient:

Collaboration diagram for Crest::CrestClient:

Public Member Functions
	CrestClient (const std::string &host, const std::string &port, bool checkVersion=false)
	CrestClient constructor. More...
	CrestClient (std::string_view url, bool checkVersion=false)
	CrestClient constructor. More...
	~CrestClient ()
	CrestClient destructor. 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 32 of file CrestApi.h.

Constructor & Destructor Documentation

CrestClient() [1/2]

Crest::CrestClient::CrestClient	(	const std::string &	_host,
		const std::string &	_port,
		bool	check_version = false
	)

CrestClient constructor.

CrestClient constructor for Internet mode.

Parameters

host	- host name of the CREST Server.
port	- port of the CREST Server.
check_version	- the parameter to switch CREST version checking, if this parameter is true, the CREST version test will be executed.

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

Parameters

_host	- host name of the CREST Server.
_port	- port of the CREST Server.
check_version	- the parameter to switch CREST version checking, if this parameter is true, the CREST version test will be executed.

Definition at line 36 of file CrestApi.cxx.

                                                                                               : m_host(_host), m_port(_port)
    {
        if (check_version == true)
        {
            checkCrestVersion();
        }
        m_request.setHost(m_host);
        m_request.setPort(m_port);
    m_request.setPrefix(m_prefix);
    }

CrestClient() [2/2]

Crest::CrestClient::CrestClient	(	std::string_view	url,
		bool	check_version = false
	)

CrestClient constructor.

CrestClient constructor for Internet mode.

Parameters

url	- URL address of the CREST Server (with port).
check_version	- the parameter to switch CREST version checking, if this parameter is true, the CREST version test will be executed.

Example:

   std::string url = "http://mvg-test-pc-03.cern.ch:8090";
   CrestClient myCrestClient = CrestClient(url);

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

Parameters

url	- URL address of the CREST Server (with port).
check_version	- the parameter to switch CREST version checking, if this parameter is true, the CREST version test will be executed. Example: std::string url = "http://mvg-test-pc-03.cern.ch:8090"; CrestClient myCrestClient = CrestClient(url);

Definition at line 61 of file CrestApi.cxx.

    {
        size_t found = url.find_first_of(':');
        size_t n = url.size();
 
        std::string_view url_new = url.substr(found + 3); // url_new is the url excluding the http part
        m_prefix = url.substr(0,found + 3); // URL prefix "http://" or "https://"
    
        size_t found1 = url_new.find_first_of(':');
        size_t found2 = url_new.find_first_of('/');
 
        std::string_view host;
        std::string_view port;
        std::string_view resources;
        if (found1 != std::string::npos && found2 != std::string::npos) {
          host = url_new.substr(0, found1);
          port = url_new.substr(found1 + 1, found2 - found1 - 1);
        } else if (found1 != std::string::npos) {
          host = url_new.substr(0, found1);
          port = url_new.substr(found1 + 1);
        } else if (found2 != std::string::npos) {
          if (m_prefix == "https://") {
            port = "443";
          }
          else port = "80";
          host = url_new.substr(0, found2);
        } else {
          if (m_prefix == "https://") {
          port = "443";
          }
          else port = "80";
          host = url_new;
        }
 
        if (found2 < n - 1)
        {
            resources = url_new.substr(found2, n - 1);
            m_PATH = resources;
        }
 
        m_port = std::string(port);
        m_host = std::string(host);
        m_request.setHost(m_host);
        m_request.setPort(m_port);
    m_request.setPrefix(m_prefix);
 
        if (check_version == true)
        {
            checkCrestVersion();
        }
        std::cout << "CrestClient::CrestClient: host = " << m_host << ", port = " << m_port << ", path = " << m_PATH << std::endl;
    }

~CrestClient()

Crest::CrestClient::~CrestClient

(

)

CrestClient destructor.

Definition at line 117 of file CrestApi.cxx.

{}

Member Function Documentation

checkCrestVersion()

void Crest::CrestClient::checkCrestVersion

(

)

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  )

private

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 )

overridevirtual

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 )

overridevirtual

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 )

overridevirtual

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 )

overridevirtual

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 )

overridevirtual

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  )

overridevirtual

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 )

overridevirtual

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 )

overridevirtual

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 ( )

overrideprivatevirtual

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

private

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 )

private

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 ( )

private

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 )

overridevirtual

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 )

overridevirtual

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 )

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 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  )

overridevirtual

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  )

overridevirtual

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

private

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

private

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

private

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 )

overridevirtual

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  )

overridevirtual

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 )

overridevirtual

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  )

overridevirtual

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  )

overridevirtual

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  )

overridevirtual

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 )

overridevirtual

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

private

Definition at line 67 of file CrestApi.h.

m_PATH

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

private

Definition at line 37 of file CrestApi.h.

m_port

std::string Crest::CrestClient::m_port

private

Definition at line 68 of file CrestApi.h.

m_prefix

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

private

Definition at line 69 of file CrestApi.h.

m_request

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

private

Definition at line 71 of file CrestApi.h.

s_ADMIN_PATH

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

inlinestaticprivate

Definition at line 40 of file CrestApi.h.

s_CREST_CLIENT_CHECK

const bool Crest::CrestClient::s_CREST_CLIENT_CHECK = false

inlinestatic

Definition at line 168 of file CrestApi.h.

s_CREST_CLIENT_VERSION

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

inlinestaticprivate

Definition at line 62 of file CrestApi.h.

s_DATA_PATH

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

inlinestaticprivate

Definition at line 50 of file CrestApi.h.

s_FOLDER_PATH

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

inlinestaticprivate

Definition at line 52 of file CrestApi.h.

s_GLOBALTAG_MAP_PATH

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

inlinestaticprivate

Definition at line 46 of file CrestApi.h.

s_GLOBALTAG_PATH

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

inlinestaticprivate

Definition at line 45 of file CrestApi.h.

s_IOV_PATH

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

inlinestaticprivate

Definition at line 41 of file CrestApi.h.

s_IOV_SIZE_PATH

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

inlinestaticprivate

Definition at line 43 of file CrestApi.h.

s_META_PATH

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

inlinestaticprivate

Definition at line 49 of file CrestApi.h.

s_METHOD_GROUPS

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

inlinestaticprivate

Definition at line 57 of file CrestApi.h.

s_METHOD_IOVS

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

inlinestaticprivate

Definition at line 56 of file CrestApi.h.

s_MGMT_INFO_PATH

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

inlinestaticprivate

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"

inlinestaticprivate

Definition at line 63 of file CrestApi.h.

s_MGMT_PATH

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

inlinestaticprivate

Definition at line 60 of file CrestApi.h.

s_MONITORING_PAYLOAD_PATH

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

inlinestaticprivate

Definition at line 48 of file CrestApi.h.

s_PAYLOAD_PATH

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

inlinestaticprivate

Definition at line 47 of file CrestApi.h.

s_RUNINFO_LIST_PATH

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

inlinestaticprivate

Definition at line 54 of file CrestApi.h.

s_RUNINFO_PATH

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

inlinestaticprivate

Definition at line 53 of file CrestApi.h.

s_TAG_PATH

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

inlinestaticprivate

Definition at line 39 of file CrestApi.h.

---

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

• CrestApi.h
• CrestApi.cxx