#include <CrestApiExt.h>

Inheritance diagram for Crest::CrestClientExt:

Collaboration diagram for Crest::CrestClientExt:

Public Member Functions
	CrestClientExt (bool rewriteIfExists, const std::string &root_folder="/tmp/crest_dump")

	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 ((nlohmann::json), 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...

	BOOST_PARAMETER_MEMBER_FUNCTION ((nlohmann::json), findAllIovsParams, tag,(required(tagname,(std::string)))(optional(size,(int), 1000)(page,(int), 0)(sort,(std::string), "id.since:ASC")(dateformat,(std::string), "ms")))
	This method finds all iovs for a given tag name. More...

	BOOST_PARAMETER_MEMBER_FUNCTION ((nlohmann::json), listGlobalTagsParams, tag,(required)(optional(name,(std::string), "")(size,(int), 1000)(page,(int), 0)(sort,(std::string), "id.since:ASC")))
	This method returns the global tag list. More...

nlohmann::json	getJson (const std::string &str)
	Auxillary method to convert string in to JSON object. More...

bool	isJson (const std::string &str)
	This method checks if a string is in the JSON format. More...

void	removeGlobalTag (const std::string &name)
	This method allows to remove a Global Tag form CREST DB. More...

void	removeTag (const std::string &tagName)
	This method allows to remove a Tag. More...

void	updateGlobalTag (const std::string &name, nlohmann::json body)
	This method allows to update a GlobalTag.Arguments: the name has to uniquely identify a global tag. More...

std::string	createFolder (nlohmann::json &body)
	Method to create a folder. More...

nlohmann::json	listFolders ()
	This method returns the folder list on CREST DB. More...

void	createGlobalTagMap (nlohmann::json &gt)
	Method to create a global tag map. More...

void	createGlobalTagMap (const std::string &globaltag, const std::string &tagname, const std::string &record, const std::string &label)
	Method to create a global tag map. More...

nlohmann::json	findGlobalTagMap (const std::string &name)
	This method search for mappings using the global tag name. More...

void	createGlobalTag (nlohmann::json &js)
	Create a global tag in the database. More...

void	createGlobalTag (const std::string &tag)
	Create a global tag in the database. More...

void	createGlobalTag (const std::string &tagname, const std::string &description)
	Create a global tag in the database. More...

std::string	findGlobalTagAsString (const std::string &name)
	Finds a global tag by name. More...

nlohmann::json	findGlobalTag (const std::string &name)
	Finds a global tag by name. More...

nlohmann::json	listGlobalTags ()
	This method finds a global tag lists. More...

nlohmann::json	listGlobalTags (const std::string &name, int size, int page, const std::string &sort)
	This method returns the global tag list. More...

std::string	listGlobalTagsAsString ()
	This method finds a global tag lists. More...

void	createIov (nlohmann::json &iov)
	This method creates an iov for a given tag in the CREST DB for the created payload. More...

nlohmann::json	findAllIovs (const std::string &tagname)
	This method finds all iovs for a given tag name. More...

nlohmann::json	findAllIovs (const std::string &tagname, int size, int page, const std::string &sort, const std::string &dateformat)
	This method finds all iovs for a given tag name. More...

int	getSize (const std::string &tagname)
	This metghod gets the number of iovs for the given tag. More...

nlohmann::json	selectGroups (const std::string &tagname)
	Select groups for a given tagname. More...

nlohmann::json	selectGroups (const std::string &tagname, long snapshot)
	Select groups for a given tagname. More...

nlohmann::json	selectIovs (const std::string &tagname)
	Select iovs for a given tagname. More...

nlohmann::json	selectIovs (const std::string &tagname, long snapshot)
	Select iovs for a given tagname. More...

nlohmann::json	selectIovs (const std::string &tagname, long since, long until, long snapshot=0)
	This method selects all iovs for a given tag name and for the selected time interval (since-until). More...

void	storeBatchIOVs (nlohmann::json &js)
	This method stores an IOV set on the CREST server. More...

nlohmann::json	listPayloadTagInfo ()
	This method retrieves monitoring information on all payloads as a list of payload tag information. More...

nlohmann::json	listPayloadTagInfo (const std::string &tagname)
	This method retrieves monitoring information on payload as a list of payload tag information. More...

void	createPayload (nlohmann::json &js)
	This method creates a payload in the CREST DB. More...

std::string	getBlob (const std::string &hash)
	This method finds payload data by hash; the payload object contains the real BLOB. More...

std::string	getBlobInStream (const std::string &hash, std::ofstream &out)
	This method finds payload data by hash; the payload object contains the real BLOB. More...

nlohmann::json	getPayloadAsJson (const std::string &hash)
	This method finds a payload resource associated to the hash. More...

std::string	getPayloadAsString (const std::string &hash)
	This method finds a payload resource associated to the hash. More...

nlohmann::json	getPayloadMetaInfo (const std::string &hash)
	This method finds a payload resource associated to the hash. More...

std::string	getPayloadMetaInfoAsString (const std::string &hash)
	This method finds a payload resource associated to the hash. More...

void	storePayload (const std::string &tag, uint64_t since, const std::string &js)
	Create a payload in the database, associated to a given iov since and tag name. More...

void	storeBatchPayloads (const std::string &tag_name, uint64_t endtime, const std::string &iovsetupload)
	This method stores several payloads in batch mode. More...

void	storeBatchPayloads (const std::string &tag_name, uint64_t endtime, nlohmann::json &js)
	This method stores several payloads in batch mode. More...

void	storeBatchPayloads (const std::string &tag_name, const std::string &iovsetupload, uint64_t endtime=0)
	This method stores several payloads in batch mode. More...

void	storeBatchPayloads (const std::string &tag_name, nlohmann::json &js, uint64_t endtime=0)
	This method stores several payloads in batch mode. More...

void	createRunLumiInfo (nlohmann::json &body)
	This method creates an entry for run information. More...

nlohmann::json	findRunLumiInfo (const urlParameters &params)
	Finds a run/lumi information lists using parameters. More...

nlohmann::json	listRunLumiInfo ()
	This method gets full list of run/lumi information data. More...

void	createTag (nlohmann::json &js)
	This method creates a tag in the CREST database. More...

void	createTag (const std::string &name, const std::string &desc, const std::string &timeType)
	This method create a tag in the CREST database. More...

void	createTag (const std::string &name, const std::string &desc, const std::string &timeType, const std::string &payloadSpec)
	This method create a tag in the CREST database. More...

nlohmann::json	findTag (const std::string &name)
	This method finds a tag by the name. More...

nlohmann::json	listTags (void)
	This method returns the tag list. More...

nlohmann::json	listTags (int size, int page)
	This method returns the tag list. More...

nlohmann::json	listTags (const std::string &name, int size, int page, const std::string &sort)
	This method returns the tag list. More...

void	updateTag (const std::string &tagname, nlohmann::json body)
	This method allows to update tag record in the CREST DB. More...

void	updateTagSpecification (const std::string &tagname, const std::string &objectType)
	This method cahnges object type specification. More...

void	createTagDump (nlohmann::json &js)
	Method to store a tag in the local file system. More...

void	flush ()
	Auxillary method to write all the data at the end of a session. More...

void	storePayloadDump (const std::string &tag, uint64_t since, const std::string &js)
	Method to store a payload in the local file system. More...

std::list< std::string >	shortListTagsFs ()
	This method returns a tag list stored in the file storage. More...

nlohmann::json	findTagFs (const std::string &name)
	This method finds a tag by the tag name in the file storage. More...

nlohmann::json	findAllIovsFs (const std::string &tagname)
	This method finds all iovs by the tag name in the file storage. More...

nlohmann::json	findAllIovsFs (const std::string &tagname, int size, int page)
	This method finds all iovs for a given tag name. More...

std::string	getFileName (const std::string &path)
	Auxillary method to extract the file name from iov hash (the hash is a path in the file storage). More...

std::string	getBlobFs (const std::string &hash)
	This method finds payload data by hash in the file storage; the payload object contains the real BLOB. More...

std::string	getBlobInStreamFs (const std::string &hash, std::ofstream &out)
	This method finds payload data by hash; the payload object contains the real BLOB. More...

void	storeBatchPayloadsFs (const std::string &tag_name, std::string &iovsetupload)
	This auxillary method stores several payloads in batch mode in the file storage. More...

void	storeBatchPayloadsFs (const std::string &tag_name, nlohmann::json &js)
	This auxillary method stores several payloads in batch mode in the file storage. More...

void	streamTest ()
	this is test only, later it will be deleted (The old method name is streamtest) More...

void	createTagMetaInfo (nlohmann::json &js)
	This method creates a tag meta info in the CREST database. More...

void	createTagMetaInfo (const std::string &tagname, nlohmann::json &js)
	This method creates a tag meta info in the CREST database. More...

nlohmann::json	getTagMetaInfo (const std::string &tagname)
	This method gets a tag meta info from the CREST database. More...

void	updateTagMetaInfo (nlohmann::json &js)
	This method updates a tag meta info in the CREST database. More...

void	updateTagMetaInfo (const std::string &tagname, nlohmann::json &js)
	This method updates a tag meta info in the CREST database. More...

void	createTagMetaInfoFs (nlohmann::json &js)
	This is an auxillary method, it creates a tag meta info on the file system storage. More...

nlohmann::json	getTagMetaInfoFs (const std::string &name)
	This is an auxillary method, it gets a tag meta info from file system storage. More...

void	updateTagMetaInfoFs (const std::string &tagname, nlohmann::json &js)
	This auxillary method updates a tag meta info in local file storage. More...

std::string	getTagMetaInfoElement (const std::string &name, nlohmann::json &js)
	Auxillary method to get an element by name from the Tag Meta Info. More...

nlohmann::json	convertTagMetaInfo2IOVDbSvc (nlohmann::json &js)
	Auxillary method to convert a Tag Meta Info from the JSON CREST Server format in to IOVDbSvc format. More...

nlohmann::json	convertTagMetaInfo2CREST (nlohmann::json &js)
	Auxillary method to convert a Tag Meta Info from the JSON IOVDbSvc format in CREST Server format. More...

nlohmann::json	getTagMetaInfoIOVDbSvc (const std::string &tagname)
	This method gets a tag meta info from the CREST database in IOVDbSvc format. More...

void	createTagMetaInfoIOVDbSvc (const std::string &tagname, nlohmann::json &js)
	This method creates a tag meta info in the CREST database. More...

void	createTagMetaInfoIOVDbSvc (const std::string &tagname, nlohmann::json &js, const std::string &description)
	This method creates a tag meta info in the CREST database. More...

void	createGlobalTagFs (nlohmann::json &js)
	The auxillary method to create a global tag in file storage. More...

nlohmann::json	findGlobalTagFs (const std::string &name)
	The auxillary method to find a global tag by name stored in file storage. More...

void	createGlobalTagMapFs (nlohmann::json &js)
	The auxillary method to create a global tag map in file storage. More...

nlohmann::json	findGlobalTagMapFs (const std::string &name)
	The auxillary method to find a global tag by name for the file storage. More...

std::string	getPayloadAsStringFS (const std::string &hash)
	This auxillary method finds a payload resource associated to the hash in the local file storage. More...

nlohmann::json	getPayloadAsJsonFS (const std::string &hash)
	This auxillary method finds a payload resource associated to the hash in the local file storage. More...

std::string	getPayloadMetaInfoAsStringFS (const std::string &hash)
	This auxillary method finds a payload resource associated to the hash in the local file storage. More...

nlohmann::json	getPayloadMetaInfoAsJsonFS (const std::string &hash)
	This auxillary method finds a payload resource associated to the hash in the local file storage. More...

int	getSizeFS (const std::string &tagname)
	This metghod gets the number of iovs for the given tag. More...

nlohmann::json	getSizeByTagFS (const std::string &tagname)
	This method gets the number of iovs for tags matching pattern. More...

nlohmann::json	selectIovsFS (const std::string &tagname, long since, long until)
	This method selects all iovs for a given tag name and for the selected time interval (since-until). More...

std::string	getHash (std::string_view str)
	The auxillary method to calculate a hash code for a given string. More...

std::string	getDateAndTime ()
	The auxillary method to get a current data and time. More...

nlohmann::json	returnJArray (nlohmann::json js)
	This auxillary method creates a JSON array from a JSON object. More...

void	getTagDataInfo (const std::string &tagname)
	This is an auxillary method for checking how many unique IOVs(hashcodes) are in an IOV list. More...

std::string	getFirstLetters (const std::string &str)
	This is an auxillary method extract first letters from the string (hash). More...

nlohmann::json	getMgmtInfo ()
	This is an auxillary method to read the CREST Server properties. More...

std::string	getCrestVersion ()
	This method returns the full CREST Server version. More...

std::string	getClientVersion ()
	This method returns the full CrestApi version. More...

int	getMajorVersion (std::string &str)
	This is an auxillary method to extract a major version number from full version string. More...

void	checkCrestVersion ()
	This method is a CREST version test. More...

nlohmann::json	getMgmtInfo2 ()
	This is an auxillary method to read the CREST Server properties. More...

std::string	getCrestVersion2 ()
	This method returns the full CREST Server version. More...

void	checkCrestVersion2 ()
	This method is a CREST version test. More...

void	removeTagFromGlobalTagMap (const std::string &global_tag, const std::string &tag, const std::string &label)
	This method removes a tag with the name tag and the label from the global tag map with name global_tag. More...

void	storeBatchPayloadsFiles (const std::string &tag_name, uint64_t endtime, nlohmann::json &js)
	This method stores several payloads from files in batch mode. More...

std::string	storeBatchPayloadFilesRequest (const std::string &tag, uint64_t endtime, const std::string &js)
	This is an auxilary method to make an request to store several payloads from files in the batch mode. More...

void	storeData (const std::string &tag, uint64_t endtime, uint64_t since, const std::string &file)
	This method stores a payload from a file in the database, associated to a given IOV since and tag name. More...

void	storeDataArray (const std::string &tag, uint64_t endtime, std::map< uint64_t, std::string > m)
	This method stores several payloads from files in batch mode. More...

void	replaceSymbols (std::string &str, const std::string &from, const std::string &to)
	This auxilary method replaces the substring from by the substring to. More...

Static Public Attributes
static const bool	s_CREST_CLIENT_CHECK = false

Private Types
enum	CrestMode { SERVER_MODE = 1, FILESYSTEM_MODE = 2 }

enum	Action { GET = 0, POST = 1, PUT = 2, DELETE = 3 }

Private Member Functions
std::string	make_url (const std::string &address) const

std::string	performRequest (const std::string &current_path, Action action, nlohmann::json &js)
	General auxiliary method to make request to the CREST Server. More...

std::string	performRequest (const std::string &current_path, Action action, nlohmann::json &js, std::ofstream &out)
	General auxillary method to make request to the CREST Server. More...

std::string	performRequest (const std::string &current_path, Action action, nlohmann::json &js, const char *method_name)
	General auxillary method to make request to the CREST Server. More...

std::string	storeBatchPayloadRequest (const std::string &tag, uint64_t endtime, const std::string &js)
	This is an auxillary method to make an request to store several payloads in the batch mode. More...

nlohmann::json	getResources (nlohmann::json &js)
	Auxillary method to get a resources parameter from new CREST server response. More...

nlohmann::json	getResFirst (nlohmann::json &js)
	Auxillary method to get the first element from resources of the new CREST server response. More...

void	checkFsException (const char *method_name)
	Auxillary method to check if the CrestApi library initialized to work with the file system. More...

int	checkErrors (const nlohmann::json &js, const char *method)
	Auxillary method to check if the JSON object contain an error message. More...

std::string	ParseXMLOutput (std::string_view xmlBuffer)
	This method removes all XML/HTML tags from a string. More...

std::string	removeCR (const std::string &str)
	This method removes all end of line and carriage return symbols from a string. More...

void	checkResult (CURLcode res, long response_code, const std::string &st, const char *method_name)
	This auxillary method checks the CURL response. More...

void	getProxyPath ()

nlohmann::json	getJson (const std::string &str, const char *method)
	Auxillary method to convert string in to JSON object. More...

std::string	getFileString (const std::string &path)
	Auxillary method to get a file as a string. More...

void	getFileList (const std::string &path)
	Auxillary method to get a file list in the given directory. More...

std::string	getEnvA (const char *varname)
	Auxillary method to get an environment variable. More...

std::string	getDataPath ()
	Auxillary method to get an environment variable DAT_PATH. More...

std::vector< std::string >	split (std::string_view str, char delim)
	Auxillary method to split a string. More...

Private Attributes
std::string	m_host {}

std::string	m_port {}

int	m_mode {}

std::string	m_root_folder {}

std::string	m_data_folder {}

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

bool	m_isRewrite {}

std::string	m_currentTag {}

std::string	m_PATH = "/api-v4.0"

char *	m_CREST_PROXY = NULL

const char *	m_CREST_PROXY_VAR = "SOCKS_PROXY"

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_METHOD_MONITOR = "MONITOR"

static const std::string	s_FS_TAG_PATH = "/tags"

static const std::string	s_FS_GLOBALTAG_PATH = "/globaltags"

static const std::string	s_FS_DATA_PATH = "/data"

static const std::string	s_FS_TAG_FILE = "/tag.json"

static const std::string	s_FS_IOV_FILE = "/iovs.json"

static const std::string	s_FS_TAGMETAINFO_FILE = "/tagmetainfo.json"

static const std::string	s_FS_META_FILE = "/meta.json"

static const std::string	s_FS_PALOAD_FILE = "/payload.json"

static const std::string	s_FS_GLOBALTAG_FILE = "/globaltag.json"

static const std::string	s_FS_MAP_FILE = "/maps.json"

static const std::string	s_FS_PATH = ""

static const int	s_FS_PREFIX_LENGTH = 3

static const std::string	s_MGMT_PATH = "/mgmt"

static const std::string	s_MGMT_INFO_PATH = "/info"

static const std::string	s_CREST_CLIENT_VERSION = "4.0"

static const std::string	s_MGMT_INFO_PATH_2 = "/actuator/info"

Detailed Description

Definition at line 30 of file CrestApiExt.h.

Member Enumeration Documentation

◆ Action

enum Crest::CrestClient::Action

privateinherited

Enumerator
GET
POST
PUT
DELETE

Definition at line 128 of file CrestApi.h.

                 {
       GET = 0, POST = 1, PUT = 2, DELETE = 3
     };

◆ CrestMode

enum Crest::CrestClient::CrestMode

privateinherited

Enumerator
SERVER_MODE
FILESYSTEM_MODE

Definition at line 125 of file CrestApi.h.

                    {
       SERVER_MODE = 1, FILESYSTEM_MODE = 2
     };

Constructor & Destructor Documentation

◆ CrestClientExt() [1/3]

Crest::CrestClientExt::CrestClientExt	(	bool	rewriteIfExists,
		const std::string &	root_folder = `"/tmp/crest_dump"`
	)

inline

Definition at line 32 of file CrestApiExt.h.

32 : CrestClient(

33 rewriteIfExists, root_folder) {}

◆ CrestClientExt() [2/3]

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

inline

Definition at line 34 of file CrestApiExt.h.

34 : CrestClient(_host, _port, _check_version) {}

◆ CrestClientExt() [3/3]

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

inline

Definition at line 35 of file CrestApiExt.h.

35 : CrestClient(url, check_version) {}

Member Function Documentation

◆ BOOST_PARAMETER_MEMBER_FUNCTION() [1/3]

Crest::CrestClientExt::BOOST_PARAMETER_MEMBER_FUNCTION	(	(nlohmann::json)	,
		findAllIovsParams	,
		tag	,
		(required(tagname,(std::string)))(optional(size,(int), 1000)(page,(int), 0)(sort,(std::string), "id.since:ASC")(dateformat,(std::string), "ms"))
	)

inline

This method finds all iovs for a given tag name.

The result is a JSON object. It is a verion of this method with all parameters. (This method is an analogue of the find_all_iovs method in Python)

Parameters

tagname	- tag name.
_size	- page size. Default value is 1000.
_page	- page number. Default value is 0.
_sort	- sorting order, "id.since:ASC" or "id.since:DESC". Default value is "id.since:ASC"
_dateformat	- date format Examples: nlohmann::json list1 = myCrestClient.findAllIovsParams("myTag"); nlohmann::json list2 = myCrestClient.findAllIovsParams("myTag",100,200); nlohmann::json list2 = myCrestClient.findAllIovsParams("myTag",_page=3,_size=5);

Definition at line 88 of file CrestApiExt.h.

                                        :ASC")
           (dateformat, (std::string), "ms")
         )
       ) {
       return findAllIovs(tagname, size, page, sort, dateformat);
     }

◆ BOOST_PARAMETER_MEMBER_FUNCTION() [2/3]

Crest::CrestClientExt::BOOST_PARAMETER_MEMBER_FUNCTION	(	(nlohmann::json)	,
		listGlobalTagsParams	,
		tag	,
		(required)(optional(name,(std::string), "")(size,(int), 1000)(page,(int), 0)(sort,(std::string), "id.since: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 121 of file CrestApiExt.h.

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

◆ BOOST_PARAMETER_MEMBER_FUNCTION() [3/3]

Crest::CrestClientExt::BOOST_PARAMETER_MEMBER_FUNCTION	(	(nlohmann::json)	,
		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 56 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 2833 of file CrestApi.cxx.

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

◆ checkCrestVersion2()

void Crest::CrestClient::checkCrestVersion2 ( )

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

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

◆ checkErrors()

int Crest::CrestClient::checkErrors	(	const nlohmann::json &	js,
		const char *	method
	)

privateinherited

Auxillary method to check if the JSON object contain an error message.

Parameters

js	- a JSON object to be checked. Example: nlohmann::json js = { "message": "Cannot create tag because name already exists: test_MvG3b", "type": "error" }
method	- method name, where was the error.

Definition at line 1875 of file CrestApi.cxx.

                                                                          {
     int result = 0;
     auto res = js.find("type");
  
     // Old format parsing:
  
     if (res != js.end()) {
       std::string type = js.value("type", " unknown type ");
       if (type == "error" || type == "info") {
         std::string message = js.value("message", " unknown message ");
         throw std::runtime_error("ERROR in " + std::string(method) + " | CREST response: " + message);
       }
     }
  
     // New format parsing:
  
     auto r1 = js.find("error");
     auto r2 = js.find("message");
  
     if (r1 != js.end()) {
       std::string error = js.value("error", " unknown error ");
       if (r2 != js.end()) {
         std::string message = js.value("message", "");
         if (message == "") {
           throw std::runtime_error("ERROR in " + std::string(method) + " | CREST response: " + error);
         } else {
           throw std::runtime_error("ERROR in " + std::string(method) + " | CREST response: " + message);
         }
       }
     }
     return result;
   }

◆ checkFsException()

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

privateinherited

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

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

Parameters

method_name - method name.

Definition at line 1908 of file CrestApi.cxx.

                                                             {
     if (m_mode == FILESYSTEM_MODE) {
       throw std::runtime_error("ERROR in " + std::string(
                                  method_name) + " This methods is unsupported for FILESYSTEM mode");
     }
     return;
   }

◆ checkResult()

void Crest::CrestClient::checkResult	(	CURLcode	res,
		long	response_code,
		const std::string &	st,
		const char *	method_name
	)

privateinherited

This auxillary method checks the CURL response.

It contais a error checking routine (common for all CURL request methods).

Parameters

res	- CURL response status,
response_code	- the CURL response code,
st	- the CURL response,
method_name	- the name on a method which calls one of the perform request methods.

Definition at line 1698 of file CrestApi.cxx.

                                                          {
     // Bad HTTP response:
  
     if (res != CURLE_OK) {
       std::string mes = "ERROR in ";
       mes += method_name;
       mes += " | ";
       throw std::runtime_error(mes + std::to_string(response_code));
     }
  
     // Errors, decoded from JSON CREST Server messages:
  
     if (isJson(st)) {
       nlohmann::json respond = getJson(st);
       checkErrors(respond, method_name);
     }
  
     // HTTP response code error interval:
  
     if (response_code >= 400 || response_code == 303) {
       std::string s = ParseXMLOutput(st);  // to remove HTML tags
       s = removeCR(s);        // to remove end lines and carridge returns
       std::string mes = "ERROR in ";
       mes += method_name;
       mes += " | ";
       throw std::runtime_error(mes + "CREST Server response : " + s);
     }
   }

◆ convertTagMetaInfo2CREST()

nlohmann::json Crest::CrestClient::convertTagMetaInfo2CREST ( nlohmann::json & js )

inherited

Auxillary method to convert a Tag Meta Info from the JSON IOVDbSvc format in CREST Server format.

Parameters

js	- the Tag Meta Info in CREST Server JSON format.

Definition at line 1955 of file CrestApi.cxx.

                                                                      {
     int colsize = 0;
  
     std::string tagInfo = js.dump();
  
     nlohmann::json result;
     result["tagInfo"] = std::move(tagInfo);
     result["description"] = "none";
  
     std::string node_desc = js["node_description"];
     std::string payload_spec = js["payload_spec"];
     nlohmann::json chan_list = js["channel_list"];
     int chan_size = chan_list.size();
     result["chansize"] = chan_size;
  
     try{
       colsize = split(payload_spec, ',').size();
     }
     catch (...) {
       colsize = 0;
     }
  
     result["colsize"] = colsize;
  
     return result;
   }

◆ convertTagMetaInfo2IOVDbSvc()

nlohmann::json Crest::CrestClient::convertTagMetaInfo2IOVDbSvc ( nlohmann::json & js )

inherited

Auxillary method to convert a Tag Meta Info from the JSON CREST Server format in to IOVDbSvc format.

Parameters

js	- the Tag Meta Info in CREST Server JSON format.

Definition at line 1948 of file CrestApi.cxx.

                                                                         {
     std::string jsName = "tagInfo";
     const char* method_name = "CrestClient::convertTagMetaInfo2IOVDbSvc";
     nlohmann::json res = getJson(js[jsName], method_name);
     return res;
   }

◆ createFolder()

std::string Crest::CrestClient::createFolder ( nlohmann::json & body )

inherited

Method to create a folder.

It is not yet realized (This method is an analogue of the create_folder method in Python)

Definition at line 1181 of file CrestApi.cxx.

                                                         {
     const char* method_name = "CrestClient::createFolder";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH + s_FOLDER_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, body, method_name);
  
     return retv;
   }

◆ createGlobalTag() [1/3]

void Crest::CrestClient::createGlobalTag ( const std::string & tag )

inherited

Create a global tag in the database.

This method allows to insert a global tag. (This method is an analogue of the create_global_tag method in Python)

Parameters

tag	- global tag as JSON string (std::string).

Definition at line 702 of file CrestApi.cxx.

                                                         {
     const char* method_name = "CrestClient::createGlobalTag";
  
     nlohmann::json js = getJson(tag, method_name);
     createGlobalTag(js);
   }

◆ createGlobalTag() [2/3]

void Crest::CrestClient::createGlobalTag	(	const std::string &	tagname,
		const std::string &	description
	)

inherited

Create a global tag in the database.

This method allows to insert a global tag, it has a reduced parameterset: the global tag name and the global tag description. (This method is an analogue of the create_global_tag method in Python) The method set the following default parameters:

  {
      "release": "1",
      "scenario": "undefined",
      "type": "UPD",
      "validity": 0,
      "workflow": "undefined"
  }

Parameters

tagname	- global tag name,
description	- global tag description,

Definition at line 709 of file CrestApi.cxx.

                                                                                           {
     nlohmann::json js =
     {
       {"name", tagname},
       {"description", description},
       {"validity", 0},
       {"release", 1},
       {"scenario", "undefined"},
       {"workflow", "undefined"},
       {"type", "UPD"}
     };
  
     createGlobalTag(js);
   }

◆ createGlobalTag() [3/3]

void Crest::CrestClient::createGlobalTag ( nlohmann::json & js )

inherited

Create a global tag in the database.

This method allows to insert a global tag. (This method is an analogue of the create_global_tag method in Python)

Parameters

js	- global tag in the JSON format. Example:

json js =
   {
      {"name","M_TEST_01"},
      {"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"},
      {"snapshotTimeMilli","null"},
      {"insertionTimeMilli","null"}
   };

Definition at line 688 of file CrestApi.cxx.

                                                     {
     const char* method_name = "CrestClient::createGlobalTag";
  
     if (m_mode == FILESYSTEM_MODE) {
       createGlobalTagFs(js);
       return;
     }
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_PATH;
     std::string retv;
     retv = performRequest(current_path, POST, js, method_name);
   }

◆ createGlobalTagFs()

void Crest::CrestClient::createGlobalTagFs ( nlohmann::json & js )

inherited

The auxillary method to create a global tag in file storage.

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

Parameters

js	- global tag in the JSON format. Example:

json js =
   {
      {"name","M_TEST_01"},
      {"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"},
      {"snapshotTimeMilli","null"},
      {"insertionTimeMilli","null"}
   };

Definition at line 2266 of file CrestApi.cxx.

                                                       {
     std::string name = "";
     try{
       name = static_cast<std::string>(js["name"]);
     }
     catch (...) {
       throw std::runtime_error("ERROR in CrestClient::createGlobalTagFs: cannot get the global tag name from JSON.");
     }
  
     std::string gTagDir = m_root_folder;
     gTagDir += s_FS_GLOBALTAG_PATH;
     std::string workDir = gTagDir;
     workDir += '/';
     workDir += name;
     std::string globalTagFile = workDir;
     globalTagFile += s_FS_GLOBALTAG_FILE;
  
  
     if (!std::filesystem::exists(std::filesystem::path(gTagDir))) {
       std::filesystem::create_directory(std::filesystem::path(gTagDir));
     }
  
     if (!std::filesystem::exists(std::filesystem::path(workDir))) {
       std::filesystem::create_directory(std::filesystem::path(workDir));
     }
  
     if (m_isRewrite) {
       if (std::filesystem::exists(std::filesystem::path(globalTagFile))) {
         std::filesystem::remove(std::filesystem::path(globalTagFile));
       }
  
       std::ofstream myfile;
  
       myfile.open(globalTagFile.c_str());
       myfile << js;
       myfile.close();
     }
  
     return;
   }

◆ createGlobalTagMap() [1/2]

void Crest::CrestClient::createGlobalTagMap	(	const std::string &	globaltag,
		const std::string &	tagname,
		const std::string &	record,
		const std::string &	label
	)

inherited

Method to create a global tag map.

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

Parameters

globaltag	- global tag name,
tagname	- tag name,
record	- record,
label	- label,

Definition at line 888 of file CrestApi.cxx.

                                                                                         {
     const char* method_name = "CrestClient::createGlobalTagMap";
  
     nlohmann::json js =
     {
       {"globalTagName", globaltag},
       {"record", record},
       {"label", label},
       {"tagName", tagname}
     };
  
     if (m_mode == FILESYSTEM_MODE) {
       createGlobalTagMapFs(js);
       return;
     }
  
     std::string current_path = m_PATH + s_GLOBALTAG_MAP_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, js, method_name);
   }

◆ createGlobalTagMap() [2/2]

void Crest::CrestClient::createGlobalTagMap ( nlohmann::json & gt )

inherited

Method to create a global tag map.

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

Parameters

gt	- global tag map in the JSON format. Example:

json gt =
   {
     {"globalTagName", "M_TEST"},
     {"record", "testing2"},
     {"label", "test2"},
     {"tagName", "test_MvG3"}
   }

Definition at line 872 of file CrestApi.cxx.

                                                        {
     const char* method_name = "CrestClient::createGlobalTagMap";
  
     if (m_mode == FILESYSTEM_MODE) {
       createGlobalTagMapFs(js);
       return;
     }
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_MAP_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, js, method_name);
   }

◆ createGlobalTagMapFs()

void Crest::CrestClient::createGlobalTagMapFs ( nlohmann::json & js )

inherited

The auxillary method to create a global tag map in file storage.

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

Parameters

gt	- global tag map in the JSON format. Example:

json gt =
   {
     {"globalTagName", "M_TEST"},
     {"record", "testing2"},
     {"label", "test2"},
     {"tagName", "test_MvG3"}
   }

Definition at line 2329 of file CrestApi.cxx.

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

◆ createIov()

void Crest::CrestClient::createIov ( nlohmann::json & iov )

inherited

This method creates an iov for a given tag in the CREST DB for the created payload.

The tag name is used in the iov creation. This tag has to be defined in the CREST DB before creating iov (This method is an analogue of the create_iov method in Python)

Parameters

iov	- an iov in the JSON format (JSON object). Example:

   json js3b =
   {
     {"tagName","test_MvG3"},
     {"since",100},
     {"insertionTime","2018-12-18T11:32:58.329+0000"},
     {"payloadHash","ABRACADABRA4"},
   };

Definition at line 370 of file CrestApi.cxx.

                                               {
     const char* method_name = "CrestClient::createIov";
  
     checkFsException(method_name);
  
     nlohmann::json iovList = nlohmann::json::array();
     iovList.push_back(js);
  
     try{
       storeBatchIOVs(iovList);
     }
     catch (const std::exception& e) {
       std::string message = "ERROR in ";
       message += method_name;
       message +=  e.what();
       throw std::runtime_error(message);
     }
  
   }

◆ createPayload()

void Crest::CrestClient::createPayload ( nlohmann::json & js )

inherited

This method creates a payload in the CREST DB.

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

Parameters

js	- payload in the JSON format. Example:

json js =
   {  {"hash", "ABRACADABRA"},
      {"version", "string"},
      {"objectType", "string"},
      {"data", "none"},
      {"streamerInfo", "none"},
      {"insertionTime", "2019-03-14T13:29:25.286Z"}
   };

Definition at line 1088 of file CrestApi.cxx.

                                                   {
     const char* method_name = "CrestClient::createPayload";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH + s_PAYLOAD_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, js, method_name);
   }

◆ createRunLumiInfo()

void Crest::CrestClient::createRunLumiInfo ( nlohmann::json & body )

inherited

This method creates an entry for run information.

Run informations go into a separate table. (This method is an analogue of the create_run_lumi_info method in Python)

Parameters

body	- run information in JSON format. Example:

   std::string str19 =
"{\"since\":\"10\",\"run\":\"7777771\",\"lb\":\"62\",\"starttime\":\"10\",\"endtime\":\"200\"}";
   json body = json::parse(str19);

Definition at line 1216 of file CrestApi.cxx.

                                                         {
     const char* method_name = "CrestClient::createRunLumiInfo";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH + s_RUNINFO_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, body, method_name);
   }

◆ createTag() [1/3]

void Crest::CrestClient::createTag	(	const std::string &	name,
		const std::string &	desc,
		const std::string &	timeType
	)

inherited

This method create a tag in the CREST database.

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

Parameters

name	- tag name.
desc	- description.
timeType	- time type.

Definition at line 246 of file CrestApi.cxx.

                                                                                                      {
     nlohmann::json js2 = {{"description", desc}, {"endOfValidity", 0},
                           {"lastValidatedTime", 0}, {"synchronization", "none"}, {"payloadSpec", "json"},
                           {"name", name}, {"timeType", timeType}};
     createTag(js2);
   }

◆ createTag() [2/3]

void Crest::CrestClient::createTag	(	const std::string &	name,
		const std::string &	desc,
		const std::string &	timeType,
		const std::string &	payloadSpec
	)

inherited

This method create a tag in the CREST database.

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

Parameters

name	- tag name.
desc	- description.
timeType	- time type..
payloadSpec	- payload specification.

Definition at line 253 of file CrestApi.cxx.

                                                             {
     nlohmann::json js2 = {{"description", desc}, {"endOfValidity", 0},
                           {"lastValidatedTime", 0}, {"synchronization", "none"}, {"payloadSpec", payloadSpec},
                           {"name", name}, {"timeType", timeType}};
  
     createTag(js2);
   }

◆ createTag() [3/3]

void Crest::CrestClient::createTag ( nlohmann::json & js )

inherited

This method creates a tag in the CREST database.

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

Parameters

js	- tag in the JSON format. Example:

   json js =
   {
     {"description", "none"},
     {"endOfValidity", 0},
     {"insertionTime", "2018-12-06T11:18:35.641+0000"},
     {"lastValidatedTime", 0},
     {"modificationTime", "2018-12-06T11:18:35.641+0000"},
     {"name", "test_M"},
     {"payloadSpec", "stave: Int32, eta: Int32, mag: Float, base: Float, free: Float"},
     {"synchronization", "none"},
     {"timeType", "time"}
   };

Definition at line 262 of file CrestApi.cxx.

                                               {
     const char* method_name = "CrestClient::createTag";
  
     if (m_mode == FILESYSTEM_MODE) {
       createTagDump(js);
       return;
     }
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, js, method_name);
   }

◆ createTagDump()

void Crest::CrestClient::createTagDump ( nlohmann::json & js )

inherited

Method to store a tag in the local file system.

The path to stored data defined by a CrestClient constructor (m_root_folder and m_data_folder variables). (This method is an analogue of the create_tag method in Python)

Parameters

js	- tag as a JSON object.

Definition at line 311 of file CrestApi.cxx.

                                                   {
     std::string name = js["name"];
  
     std::string rootDir = m_root_folder;
     rootDir += s_FS_TAG_PATH;
     if (!std::filesystem::exists(std::filesystem::path(rootDir))) {
       std::filesystem::create_directory(std::filesystem::path(rootDir));
     }
  
     std::string workDir = m_root_folder;
     workDir += s_FS_TAG_PATH;
     workDir += '/';
     workDir += name;
     if (!std::filesystem::exists(std::filesystem::path(workDir))) {
       std::filesystem::create_directory(std::filesystem::path(workDir));
     }
     if (name.compare(m_currentTag) != 0 && m_isRewrite) {
       flush();
     }
     m_currentTag = name;
     std::string tagFile = workDir + s_FS_TAG_FILE;
     std::string iovFile = workDir + s_FS_IOV_FILE;
  
     if (m_isRewrite) {
       if (std::filesystem::exists(std::filesystem::path(tagFile))) {
         std::filesystem::remove(std::filesystem::path(tagFile));
       }
       if (std::filesystem::exists(std::filesystem::path(iovFile))) {
         std::filesystem::remove(std::filesystem::path(iovFile));
       }
       std::ofstream myfile;
       myfile.open(tagFile.c_str());
       myfile << js;
       myfile.close();
     }
     if (m_data.find(name) == m_data.end()) {
       m_data.insert(std::pair<std::string, nlohmann::json>(name, nlohmann::json(nlohmann::json::value_t::array)));
     }
   }

◆ createTagMetaInfo() [1/2]

void Crest::CrestClient::createTagMetaInfo	(	const std::string &	tagname,
		nlohmann::json &	js
	)

inherited

This method creates a tag meta info in the CREST database.

(The tag meta info JSON contains the tag name, that is why it is better to use the method variant without tagname parameter. This method exists for the compatibility reasons.)

Parameters

tagname	- tag name,
js	- tag meta info in the JSON format. Example:

   nlohmann::json js =
   {
     {"tagName", "test_MvG4"},
     {"description", "desc-01"},
     {"tagInfo", "taginf-01"},
     {"chansize", 0},
     {"colsize", 0},
     {"insertionTime", "2019-03-14T13:29:25.286Z"}
   };

Definition at line 2028 of file CrestApi.cxx.

                                                                                 {
     std::string name = js["tagName"];
     if (tagname != name) {
       throw std::runtime_error("ERROR in CrestClient::createTagMetaInfo tagname in method and in JSON are different.");
     }
     createTagMetaInfo(js);
     return;
   }

◆ createTagMetaInfo() [2/2]

void Crest::CrestClient::createTagMetaInfo ( nlohmann::json & js )

inherited

This method creates a tag meta info in the CREST database.

Parameters

js	- tag meta info in the JSON format. Example:

   nlohmann::json js =
   {
     {"tagName", "test_MvG4"},
     {"description", "desc-01"},
     {"tagInfo", "taginf-01"},
     {"chansize", 0},
     {"colsize", 0},
     {"insertionTime", "2019-03-14T13:29:25.286Z"}
   };

Definition at line 1998 of file CrestApi.cxx.

                                                       {
     const char* method_name = "CrestClient::createTagMetaInfo";
  
     if (m_mode == FILESYSTEM_MODE) {
       createTagMetaInfoFs(js);
       return;
     }
  
     std::string tagname = "";
     try{
       tagname = static_cast<std::string> (js["tagName"]);
     }
     catch (...) {
       throw std::runtime_error(
               "ERROR in CrestClient::createTagMetaInfo cannot get the tag name from tag meta info JSON.");
     }
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
     current_path += '/';
     current_path += tagname;
     current_path += s_META_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
   }

◆ createTagMetaInfoFs()

void Crest::CrestClient::createTagMetaInfoFs ( nlohmann::json & js )

inherited

This is an auxillary method, it creates a tag meta info on the file system storage.

Parameters

js	- tag meta info in the JSON format. Example:

   nlohmann::json js =
   {
     {"tagName", "test_MvG4"},
     {"description", "desc-01"},
     {"tagInfo", "taginf-01"},
     {"chansize", 0},
     {"colsize", 0},
     {"insertionTime", "2019-03-14T13:29:25.286Z"}
   };

Definition at line 2165 of file CrestApi.cxx.

                                                         {
     std::string name = "";
     try{
       name = static_cast<std::string> (js["tagName"]);
     }
     catch (...) {
       throw std::runtime_error(
               "ERROR in CrestClient::createTagMetaInfoFs cannot get the tag name from tag meta info JSON.");
     }
     std::string workDir = m_root_folder;
     workDir += s_FS_TAG_PATH;
  
     if (!std::filesystem::exists(std::filesystem::path(workDir))) {
       std::filesystem::create_directory(std::filesystem::path(workDir));
     }
  
     workDir += '/';
     workDir += name;
     std::string tagMetaFile = workDir;
     tagMetaFile += s_FS_TAGMETAINFO_FILE;
  
     if (!std::filesystem::exists(std::filesystem::path(workDir))) {
       std::filesystem::create_directory(std::filesystem::path(workDir));
     }
  
     if (m_isRewrite) {
       if (std::filesystem::exists(std::filesystem::path(tagMetaFile))) {
         std::filesystem::remove(std::filesystem::path(tagMetaFile));
       }
  
       std::ofstream myfile;
  
       myfile.open(tagMetaFile.c_str());
       myfile << js;
       myfile.close();
     }
  
     return;
   }

◆ createTagMetaInfoIOVDbSvc() [1/2]

void Crest::CrestClient::createTagMetaInfoIOVDbSvc	(	const std::string &	tagname,
		nlohmann::json &	js
	)

inherited

This method creates a tag meta info in the CREST database.

Parameters

tagname	- tag name
js	- tag meta info in the JSON IOVDbSvc format. Example:

{
   "channel_list": [
       {"0": "ATLAS_PREFERRED0"},
       {"1": "ATLAS_PREFERRED1"}
    ],
   "node_description": "description of the node",
   "payload_spec":
     "AlgorithmID:UInt32,LBAvInstLumi:Float,LBAvEvtsPerBX:Float,LumiType:UInt32,Valid:UInt32,BunchInstLumi:Blob64k"
 }

Definition at line 2134 of file CrestApi.cxx.

                                                                                         {
     const char* method_name = "CrestClient::createTagMetaInfoIOVDbSvc";
  
     checkFsException(method_name);
  
     nlohmann::json arg = convertTagMetaInfo2CREST(js);
     arg["tagName"] = tagname;
  
     createTagMetaInfo(arg);
  
     return;
   }

◆ createTagMetaInfoIOVDbSvc() [2/2]

void Crest::CrestClient::createTagMetaInfoIOVDbSvc	(	const std::string &	tagname,
		nlohmann::json &	js,
		const std::string &	description
	)

inherited

This method creates a tag meta info in the CREST database.

Parameters

tagname	- tag name
description	- tag meta info description, this parameter is a part of the tag meta info in CREST format
js	- tag meta info in the JSON IOVDbSvc format. Example:

 {
   "channel_list": [
       {"0": "ATLAS_PREFERRED0"},
       {"1": "ATLAS_PREFERRED1"}
    ],
   "node_description": "description of the node",
   "payload_spec":
     "AlgorithmID:UInt32,LBAvInstLumi:Float,LBAvEvtsPerBX:Float,LumiType:UInt32,Valid:UInt32,BunchInstLumi:Blob64k"
}

Definition at line 2147 of file CrestApi.cxx.

                                                                             {
     const char* method_name = "CrestClient::createTagMetaInfoIOVDbSvc";
  
     checkFsException(method_name);
  
     nlohmann::json arg = convertTagMetaInfo2CREST(js);
     arg["tagName"] = tagname;
     arg["description"] = description;
  
     createTagMetaInfo(arg);
  
     return;
   }

◆ findAllIovs() [1/2]

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

inherited

This method finds all iovs for a given tag name.

The result is a JSON object. (This method is an analogue of the find_all_iovs method in Python)

Parameters

tagname - tag name.

Returns: JSON array with the IOV list. Example:

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

IOV JSON parameters:

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

Definition at line 390 of file CrestApi.cxx.

                                                                 {
     const char* method_name = "CrestClient::findAllIovs";
  
     if (m_mode == FILESYSTEM_MODE) {
       return findAllIovsFs(tagname);
     }
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
     current_path += "?method=";
     current_path += s_METHOD_IOVS;
     current_path += "&tagname=";
     current_path += tagname;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     auto answer = getResources(respond); 
     return answer;
   }

◆ findAllIovs() [2/2]

nlohmann::json Crest::CrestClient::findAllIovs	(	const std::string &	tagname,
		int	size,
		int	page,
		const std::string &	sort,
		const std::string &	dateformat
	)

inherited

This method finds all iovs for a given tag name.

The result is a JSON object. It is a version of this method with all parameters. (This method is an analogue of the find_all_iovs method in Python)

Parameters

tagname	- tag name.
size	- page size.
page	- page number.
sort	- sort pattern (for example "{id.since:ASC}").
dateformat	- format of the input time fields.

Returns: JSON array with the IOV list.
See the IOV list JSON description in CrestClient::findAllIovs method.

Definition at line 415 of file CrestApi.cxx.

                                                                        {
     const char* method_name = "CrestClient::findAllIovs";
  
     if (m_mode == FILESYSTEM_MODE) {
       return findAllIovsFs(tagname);
     }
  
     // http request examples:
     // http://crest-01.cern.ch:9090/crestapi/iovs?method=IOVS&tagname=MuonAlignMDTBarrelAlign-RUN2-BA_ROLLING_12-BLKP-UPD4-00
     // http://crest-02.cern.ch:8090/crestapi/tags?size=10&page=2&sort=name:DESC
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
     current_path += "?method=";
     current_path += s_METHOD_IOVS;
     current_path += "&tagname=";
     current_path += tagname;
     current_path += "&size=";
     current_path += std::to_string(size);
     current_path += "&page=";
     current_path += std::to_string(page);
     current_path += "&sort=";
     current_path += sort;
     current_path += "&dateformat=";
     current_path += dateformat;
  
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ findAllIovsFs() [1/2]

nlohmann::json Crest::CrestClient::findAllIovsFs ( const std::string & tagname )

inherited

This method finds all iovs by the tag name in the file storage.

This is the auxilary method. It is called by find_all_iovs method when CrestClient is initialized in the file storage mode. (This method is an analogue of the find_all_iovs method in Python)

Parameters

tagname - tag name.

Returns: JSON array with the IOV list.
See the IOV list JSON description in CrestClient::findAllIovs method.

Definition at line 1781 of file CrestApi.cxx.

                                                                   {
     nlohmann::json js = nullptr;
     std::string file_path = m_root_folder;
     file_path += '/';
     file_path += s_FS_TAG_PATH;
     file_path += '/';
     file_path += tagname;
     file_path += s_FS_IOV_FILE;
  
     try{
       std::string tag = getFileString(file_path);
       js = nlohmann::json::parse(tag);
     }
     catch (...) {
       throw std::runtime_error("ERROR in CrestClient::findAllIovsFs : cannot get the iov information form file storage");
     }
  
     return js;
   }

◆ findAllIovsFs() [2/2]

nlohmann::json Crest::CrestClient::findAllIovsFs	(	const std::string &	tagname,
		int	size,
		int	page
	)

inherited

This method finds all iovs for a given tag name.

The result is a JSON object. It is a verion of this method with all parameters. This method works with the file data storage. (This method is an analogue of the find_all_iovs method in Python)

Parameters

tagname	- tag name.
size	- page size.
page	- page number.

Returns: JSON array with the IOV list.
See the IOV list JSON description in CrestClient::findAllIovs method.

Definition at line 2664 of file CrestApi.cxx.

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

◆ findGlobalTag()

nlohmann::json Crest::CrestClient::findGlobalTag ( const std::string & name )

inherited

Finds a global tag by name.

This method will search for a global tag with the given name. Only one global tag should be returned. (This method is an analogue of the find_global_tag method in Python) This method returns the global tag as a JSON object.

Parameters

name	- global tag name

Returns: JSON with the global tag. Example:

globalTag(ATLAS-P2-ITK-22-02-00)=
 [
   {
     "name": "ATLAS-P2-ITK-22-02-00",
     "validity": 1,
     "description": "A geometry like global tag",
     "release": "1",
     "insertionTime": "2023-11-01T08:45:09+0000",
     "snapshotTime": "2023-11-01T08:45:09+0000",
     "scenario": "undefined",
     "workflow": "undefined",
     "type": "U",
     "insertionTimeMilli": 1698828309000,
     "snapshotTimeMilli": 1698828309000
  }
]

Global Tag JSON parameters:

name                    string              global tag name
validity                number              validity
description             string              global tag description
release                 string              release
insertionTime           string($date-time)  insertion time
snapshotTime            string($date-time)  snapshot time
scenario                string              scenario
workflow                string              workfow
type                    string              type
snapshotTimeMilli       integer($int64)     snapshot time (in milliseconds)
insertionTimeMilli      integer($int64)     insertion time (in milliseconds)

Definition at line 745 of file CrestApi.cxx.

                                                                {
     const char* method_name = "CrestClient::findGlobalTag";
  
     if (m_mode == FILESYSTEM_MODE) {
       return findGlobalTagFs(name);
     }
  
     std::string retv = findGlobalTagAsString(name);
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ findGlobalTagAsString()

std::string Crest::CrestClient::findGlobalTagAsString ( const std::string & name )

inherited

Finds a global tag by name.

This method will search for a global tag with the given name. Only one global tag should be returned. (This method is an analogue of the find_global_tag_as_string method in Python) This method returns the global tag as a string.

Parameters

name	- global tag name

Returns: string with the global tag in JSON format.
See the global tag JSON description in CrestClient::findGlobalTag method.

Definition at line 724 of file CrestApi.cxx.

                                                                     {
     const char* method_name = "CrestClient::findGlobalTagAsString";
  
     if (m_mode == FILESYSTEM_MODE) {
       nlohmann::json j = findGlobalTagFs(name);
       std::string s = j.dump();
       return s;
     }
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_PATH;
     current_path += '/';
     current_path += name;
     std::string retv;
  
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, method_name);
  
     return retv;
   }

◆ findGlobalTagFs()

nlohmann::json Crest::CrestClient::findGlobalTagFs ( const std::string & name )

inherited

The auxillary method to find a global tag by name stored in file storage.

(This method is an analogue of the find_global_tag method in Python) This method returns the global tag as a JSON object.

Parameters

name	- global tag name

Returns: JSON with the global tag.
See the tag JSON description in CrestClient::findGlobalTag method.

Definition at line 2307 of file CrestApi.cxx.

                                                                  {
     nlohmann::json js = nullptr;
  
     std::string workDir = m_root_folder;
     workDir += s_FS_GLOBALTAG_PATH;
     workDir += '/';
     workDir += name;
     std::string file_path = workDir;
     file_path += s_FS_GLOBALTAG_FILE;
  
     try{
       std::string tag = getFileString(file_path);
       js = nlohmann::json::parse(tag);
     }
     catch (...) {
       throw std::runtime_error(
               "ERROR in CrestClient::getGlobalTagFs: cannot get the global tag " + name + " form the file storage.");
     }
  
     return returnJArray(js);
   }

◆ findGlobalTagMap()

nlohmann::json Crest::CrestClient::findGlobalTagMap ( const std::string & name )

inherited

This method search for mappings using the global tag name.

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

Parameters

name	- name of a global tag

Returns: JSON with the global tag map. Example:

 global tag map(CREST-MC23-SDR-RUN3-02)=
 [
   {
      "globalTagName": "CREST-MC23-SDR-RUN3-02",
      "record": "None",
      "label": "/TGC/NSW/CHARGE/SIDEA",
      "tagName": "sTgcPdoSideA-Const-1p0-icpt0"
   },
   ...
 ]

 Global Tag Map JSON parameters:
  globalTagName    string   global tag name
 record           string   record
 label            string   label
 tagName          string   tag name

Definition at line 849 of file CrestApi.cxx.

                                                                   {
     const char* method_name = "CrestClient::findGlobalTagMap";
  
     if (m_mode == FILESYSTEM_MODE) {
       return findGlobalTagMapFs(name);
     }
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_MAP_PATH;
     current_path += '/';
     current_path += name;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ findGlobalTagMapFs()

nlohmann::json Crest::CrestClient::findGlobalTagMapFs ( const std::string & name )

inherited

The auxillary method to find a global tag by name for the file storage.

This method will search for a global tag with the given name. Only one global tag should be returned. (This method is an analogue of the find_global_tag method in Python) This method returns the global tag as a JSON object.

Parameters

name	- global tag name

Returns: JSON with the global tag map.
See the global tag map JSON description in CrestClient::findGlobalTagMap method.

Definition at line 2412 of file CrestApi.cxx.

                                                                     {
     nlohmann::json js = nullptr;
  
     std::string workDir = m_root_folder + s_FS_GLOBALTAG_PATH;
     std::string file_path = workDir;
     file_path += '/';
     file_path += name;
     file_path += s_FS_MAP_FILE;
  
     try{
       std::string tag = getFileString(file_path);
       js = nlohmann::json::parse(tag);
     }
     catch (...) {
       throw std::runtime_error(
               "ERROR in CrestClient::getGlobalTagMapFs: cannot get the global tag map " + name +
               " form the file storage.");
     }
  
     return js;
   }

◆ findRunLumiInfo()

nlohmann::json Crest::CrestClient::findRunLumiInfo ( const urlParameters & params )

inherited

Finds a run/lumi information lists using parameters.

This method allows to perform search. (This method is an analogue of the find_run_lumi_info method in Python) @params params - search parameters. Example:

   urlParameters params28;
   params28.add("from","2018010101");
   params28.add("to","2019050500");
   params28.add("format","Time");
   json tag_info28 = myCrestClientF.findRunLumiInfo(params28);

Definition at line 1228 of file CrestApi.cxx.

                                                                        {
     const char* method_name = "CrestClient::findRunLumiInfo";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_RUNINFO_PATH;
     current_path += s_RUNINFO_LIST_PATH;
     current_path += '?';
     current_path += params.getParams();
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ findTag()

nlohmann::json Crest::CrestClient::findTag ( const std::string & name )

inherited

This method finds a tag by the name.

The result is a JSON object (This method is an analogue of the find_tag method in Python)

Parameters

name	- tag name

Returns: JSON with the tag. Example:

tag(AtlasLayerMat_v16_ATLAS-R1-2012-02)=
[
  {
      "name": "AtlasLayerMat_v16_ATLAS-R1-2012-02",
      "timeType": "run-lumi",
      "payloadSpec": "crest-json-single-iov",
      "synchronization": "none",
      "description": "Migrated from {\"dbname":"OFLP200","nodeFullpath":"/GLOBAL/TrackingGeo/LayerMaterialV2","schemaName":"COOLOFL_GLOBAL"}",
      "lastValidatedTime": 0,
      "endOfValidity": 0,
      "insertionTime": "2023-09-22T12:22:07+0000",
      "modificationTime": "2023-09-22T12:22:07+0000",
  }
]

JSON parameters:

 name                string              tag  name 
 timeType            string              time type 
 payloadSpec         string              payload specification
 synchronization     string              synchronization
 description         string              tag description
 lastValidatedTime   number              last validated time
 endOfValidity       number              end of validity
 insertionTime       string($date-time)  insertion time
 modificationTime    string($date-time)  modification time

See the tag JSON description in CrestClient::findTag method.

Definition at line 226 of file CrestApi.cxx.

                                                             {
     const char* method_name = "findTag";
  
     if (m_mode == FILESYSTEM_MODE) {
       return findTagFs(tagName);
     }
  
     std::string current_path = m_PATH + s_TAG_PATH + '/' + tagName;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ findTagFs()

nlohmann::json Crest::CrestClient::findTagFs ( const std::string & name )

inherited

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

This is the auxilary method. It is called by findTag method when CrestClient is initialized in the file storage mode. (This method is an analogue of the find_tag method in Python)

Parameters

name	- tag name.

Returns: JSON with the tag.
See the tag JSON description in CrestClient::findTag method.

Definition at line 1762 of file CrestApi.cxx.

                                                            {
     nlohmann::json js = nullptr;
     std::string file_path = m_root_folder;
     file_path += '/';
     file_path += s_FS_TAG_PATH;
     file_path += '/';
     file_path += name;
     file_path += s_FS_TAG_FILE;
     try{
       std::string tag = getFileString(file_path);
       js = nlohmann::json::parse(tag);
     }
     catch (...) {
       throw std::runtime_error("ERROR in CrestClient::findTagFs cannot get the tag information form file storage.");
     }
  
     return returnJArray(js);
   }

◆ flush()

void Crest::CrestClient::flush ( )

inherited

Auxillary method to write all the data at the end of a session.

The path to stored data defined by a CrestClient constructor (in m_root_folder and m_data_folder variables).

Definition at line 351 of file CrestApi.cxx.

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

◆ getBlob()

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

inherited

This method finds payload data by hash; the payload object contains the real BLOB.

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

Parameters

hash - hash

Definition at line 915 of file CrestApi.cxx.

                                                       {
     const char* method_name = "CrestClient::getBlob";
  
     if (m_mode == FILESYSTEM_MODE) {
       return getBlobFs(hash);
     }
  
     std::string current_path = m_PATH;
     current_path += s_PAYLOAD_PATH;
     current_path += '/';
     current_path += hash;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     return retv;
   }

◆ getBlobFs()

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

inherited

This method finds payload data by hash in the file storage; the payload object contains the real BLOB.

The result returns as a string. This is an auxillary method called by getBlob method when CrestClient innitialized in the file storage mode. (This method is an analogue of the get_blob method in Python)

Parameters

hash - hash

Definition at line 2600 of file CrestApi.cxx.

                                                         {
     try{
       std::string str = getPayloadAsStringFS(hash);
       return str;
     }
     catch (...) {
       throw std::runtime_error("ERROR in CrestClient::getBlobFs : cannot get the blob information form file storage");
     }
   }

◆ getBlobInStream()

std::string Crest::CrestClient::getBlobInStream	(	const std::string &	hash,
		std::ofstream &	out
	)

inherited

This method finds payload data by hash; the payload object contains the real BLOB.

The result returns in the stream "out" (BE CAREFUL!). (This method is an analogue of the get_blob method in Python)

Parameters

	hash	- hash
[out]	out	- output stream to get the result.

Definition at line 936 of file CrestApi.cxx.

                                                                                 {
     if (m_mode == FILESYSTEM_MODE) {
       return getBlobInStreamFs(hash, out);
     }
  
     std::string current_path = m_PATH;
     current_path += s_PAYLOAD_PATH;
     current_path += '/';
     current_path += hash;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, out);
  
     return retv;
   }

◆ getBlobInStreamFs()

std::string Crest::CrestClient::getBlobInStreamFs	(	const std::string &	hash,
		std::ofstream &	out
	)

inherited

This method finds payload data by hash; the payload object contains the real BLOB.

The result returns in the stream "out" (BE CARREFULL!). This is an auxillary method called by getBlobInStream method when CrestClient innitialized in the file storage mode. (This method is an analogue of the get_blob method in Python)

Parameters

	hash	- hash
[out]	out	- output stream to get the result.

Definition at line 2610 of file CrestApi.cxx.

                                                                                   {
     std::string line;
     std::string str = "";
  
     std::string workDir = m_data_folder;
     workDir += '/';
     workDir += getFirstLetters(hash);
     workDir += '/';
     workDir += hash;
  
     std::string file_path = workDir;
     file_path += "/payload.json";
  
     std::ifstream in(file_path);
  
     if (in.is_open() && out.is_open()) {
  
       while (getline(in, line)) {
         out << line << std::endl;
       }
     } else {
       throw std::runtime_error(
               "ERROR in CrestClient::getBlobInStreamFs : cannot get the blob information form file storage");
     }
     in.close();
  
     return str;
   }

◆ getClientVersion()

std::string Crest::CrestClient::getClientVersion ( )

inherited

This method returns the full CrestApi version.

Definition at line 2809 of file CrestApi.cxx.

                                           {
     return s_CREST_CLIENT_VERSION;
   }

◆ getCrestVersion()

std::string Crest::CrestClient::getCrestVersion ( )

inherited

This method returns the full CREST Server version.

Definition at line 2783 of file CrestApi.cxx.

                                          {
     const char* method_name = "getCrestVersion";
     checkFsException(method_name);
  
     std::string version = "";
     nlohmann::json info = getMgmtInfo();
  
     auto subjectIdIter1 = info.find("build");
     if (subjectIdIter1 != info.end()){
       nlohmann::json  build = info["build"];
       auto subjectIdIter2 = build.find("version");
       if (subjectIdIter2 != build.end()){
         version = build["version"];
       }
       else {
         throw std::runtime_error("ERROR in CrestClient::" + (std::string) method_name + ": CREST Server response has no \"version\" key.");
       } // iterator 2  
  
     }
     else {
       throw std::runtime_error("ERROR in CrestClient::" + (std::string) method_name + ": CREST Server response has no \"build\" key.");
     } // iterator 1
  
     return version;
   }

◆ getCrestVersion2()

std::string Crest::CrestClient::getCrestVersion2 ( )

inherited

This method returns the full CREST Server version.

Definition at line 2863 of file CrestApi.cxx.

                                           {
     const char* method_name = "getCrestVersion";
     checkFsException(method_name);
  
     std::string version = "";
     nlohmann::json info = getMgmtInfo2();
  
     auto subjectIdIter1 = info.find("build");
     if (subjectIdIter1 != info.end()){
       nlohmann::json  build = info["build"];
       auto subjectIdIter2 = build.find("version");
       if (subjectIdIter2 != build.end()){
         version = build["version"];
       }
       else {
         throw std::runtime_error("ERROR in CrestClient::" + (std::string) method_name + ": CREST Server response has no \"version\" key.");
       } // iterator 2  
  
     }
     else {
       throw std::runtime_error("ERROR in CrestClient::" + (std::string) method_name + ": CREST Server response has no \"build\" key.");
     } // iterator 1
  
     return version;
   }

◆ getDataPath()

std::string Crest::CrestClient::getDataPath ( )

privateinherited

Auxillary method to get an environment variable DAT_PATH.

Definition at line 1866 of file CrestApi.cxx.

                                      {
     const char* varName = "DAT_PATH";
  
     std::string respond = getEnvA(varName);
     respond += "/data/crestapi";
  
     return respond;
   }

◆ getDateAndTime()

std::string Crest::CrestClient::getDateAndTime ( )

inherited

The auxillary method to get a current data and time.

It used to create a payload meta info on the local file storage using the storePayloadDump method.

Definition at line 2534 of file CrestApi.cxx.

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

◆ getEnvA()

std::string Crest::CrestClient::getEnvA ( const char * varname )

privateinherited

Auxillary method to get an environment variable.

Parameters

varname - a variable name.

Definition at line 1856 of file CrestApi.cxx.

                                                     {
     std::string respond = "";
  
     char* pPath;
     const char* c = varname;
     pPath = std::getenv(c);
     if (pPath != NULL) respond = std::string(pPath);
     return respond;
   }

◆ getFileList()

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

privateinherited

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

(The old method name - get_file_list)

Parameters

path	- path to the directory.

Definition at line 1739 of file CrestApi.cxx.

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

◆ getFileName()

std::string Crest::CrestClient::getFileName ( const std::string & path )

inherited

Auxillary method to extract the file name from iov hash (the hash is a path in the file storage).

(The old method name is get_filename)

Parameters

path	- an iov hash.

Definition at line 1802 of file CrestApi.cxx.

                                                           {
     int size = path.size();
     int pos = path.find(':');
  
     return path.substr(pos + 3, size);
   }

◆ getFileString()

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

privateinherited

Auxillary method to get a file as a string.

(The old method name - get_file_string)

Parameters

path	- path to the file.

Definition at line 1733 of file CrestApi.cxx.

                                                             {
     std::ifstream ifs(path);
     return std::string((std::istreambuf_iterator<char>(ifs)),
                        (std::istreambuf_iterator<char>()));
   }

◆ getFirstLetters()

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

inherited

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

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

Parameters

str	- string to extract first letters.

Definition at line 2762 of file CrestApi.cxx.

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

◆ getHash()

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

inherited

The auxillary method to calculate a hash code for a given string.

This method uses SHA256 algorithm (PicoSHA2 C++ library)

Parameters

str	- a string

Definition at line 2441 of file CrestApi.cxx.

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

◆ getJson() [1/2]

nlohmann::json Crest::CrestClient::getJson ( const std::string & str )

inherited

Auxillary method to convert string in to JSON object.

Parameters

str	- string (std::string)

Returns: - JSON object as nlohmann::json

Definition at line 1650 of file CrestApi.cxx.

                                                         {
     return getJson(str, "");
   }

◆ getJson() [2/2]

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

privateinherited

Auxillary method to convert string in to JSON object.

Parameters

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

Returns: - JSON object as nlohmann::json

Definition at line 1631 of file CrestApi.cxx.

                                                                             {
     try {
       nlohmann::json js = nlohmann::json::parse(str);
       return js;
     }
     catch (nlohmann::json::parse_error& e) {
       if (method == nullptr || *method == '\0') {
         // method name is undefined
  
         std::string wh = e.what();
         throw std::runtime_error("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 std::runtime_error("ERROR in " + std::string(method) + " | CREST Server response : " + str3);
       }
     }
   }

◆ getMajorVersion()

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

inherited

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

Definition at line 2813 of file CrestApi.cxx.

                                                 {
     int v = -1;
     int n =  str.find('.'); 
  
     if (n < 1) {
       throw std::runtime_error("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 std::runtime_error("ERROR in CrestClient::getMajorVersion: string \"" + str + "\" does not contain major version.");
     }
  
     return v;
   }

◆ getMgmtInfo()

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

inherited

This is an auxillary 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 2767 of file CrestApi.cxx.

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

◆ getMgmtInfo2()

nlohmann::json Crest::CrestClient::getMgmtInfo2 ( )

inherited

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

This method is an analogue of the getMgmtInfo() method, but it uses another path to get the data.

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

                                          {
     const char* method_name = "getMgmtInfo2";
  
     checkFsException(method_name);
  
     std::string current_path =  s_MGMT_INFO_PATH_2;
     std::string retv;
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return respond;
   }

◆ getPayloadAsJson()

nlohmann::json Crest::CrestClient::getPayloadAsJson ( const std::string & hash )

inherited

This method finds a payload resource associated to the hash.

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

Parameters

hash - hash.

Definition at line 1042 of file CrestApi.cxx.

                                                                   {
     const char* method_name = "CrestClient::getPayloadAsJson";
  
     if (m_mode == FILESYSTEM_MODE) {
       return getPayloadAsJsonFS(hash);
     }
  
     std::string current_path = m_PATH;
     current_path += s_PAYLOAD_PATH;
     current_path += '/';
     current_path += hash;
     current_path += "?format=DTO";
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return respond;
   }

◆ getPayloadAsJsonFS()

nlohmann::json Crest::CrestClient::getPayloadAsJsonFS ( const std::string & hash )

inherited

This auxillary method finds a payload resource associated to the hash in the local file storage.

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

Parameters

hash - hash.

Definition at line 2566 of file CrestApi.cxx.

                                                                     {
     std::string res = getPayloadAsStringFS(hash);
     nlohmann::json respond = getJson(res, "getPayloadAsJsonFS");
     return respond;
   }

◆ getPayloadAsString()

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

inherited

This method finds a payload resource associated to the hash.

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

Parameters

hash - hash.

Definition at line 1066 of file CrestApi.cxx.

                                                                  {
     const char* method_name = "CrestClient::getPayloadAsString";
  
     if (m_mode == FILESYSTEM_MODE) {
       return getPayloadAsStringFS(hash);
     }
  
     std::string current_path = m_PATH;
     current_path += s_PAYLOAD_PATH;
     current_path += '/';
     current_path += hash;
     current_path += "?format=BLOB";
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     return retv;
   }

◆ getPayloadAsStringFS()

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

inherited

This auxillary method finds a payload resource associated to the hash in the local file storage.

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

Parameters

hash - hash.

Definition at line 2547 of file CrestApi.cxx.

                                                                    {
     std::string workDir = m_data_folder;
     workDir += '/';
     workDir += getFirstLetters(hash);
     workDir += '/';
     workDir += hash;
     std::string filePath = workDir + "/payload.json";
     std::string res = "";
  
     try{
       res = getFileString(filePath);
     }
     catch (...) {
       throw std::runtime_error("ERROR in CrestClient::getPayloadAsStringFS cannot get the payload form file storage.");
     }
  
     return res;
   }

◆ getPayloadMetaInfo()

nlohmann::json Crest::CrestClient::getPayloadMetaInfo ( const std::string & hash )

inherited

This method finds a payload resource associated to the hash.

This method retrieves metadata of the payload resource. The result is a JSON object. (This method is an analogue of the get_payload_meta_info method in Python)

Parameters

hash - hash.

Returns: JSON with the payload meta info. Example:

 {
    "checkSum": "SHA-256",
    "compressionType": "none",
    "hash": "8f7b558c70032fb0e93f608408b0d49d2af75572d29877013226c65ffc01dbc5",
    "insertionTime": "2023-09-22T12:22:07+0000",
    "objectName": "none",
    "objectType": "iovs",
    "size": 246,
    "version": "default"
 }

Definition at line 956 of file CrestApi.cxx.

                                                                     {
     const char* method_name = "CrestClient::getPayloadMetaInfo";
  
     if (m_mode == FILESYSTEM_MODE) {
       return getPayloadMetaInfoAsJsonFS(hash);
     }
  
     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 = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return respond;
   }

◆ getPayloadMetaInfoAsJsonFS()

nlohmann::json Crest::CrestClient::getPayloadMetaInfoAsJsonFS ( const std::string & hash )

inherited

This auxillary method finds a payload resource associated to the hash in the local file storage.

This method retrieves metadata of the payload resource. The result is a JSON object. (This method is an analogue of the get_payload_meta_info method in Python)

Parameters

hash - hash.

Returns: JSON with the payload meta info.
See the payload meta info JSON example in CrestClient::getPayloadMetaInfo method.

Definition at line 2594 of file CrestApi.cxx.

                                                                             {
     std::string res = getPayloadMetaInfoAsStringFS(hash);
     nlohmann::json respond = getJson(res, "getPayloadAsJsonFS");
     return returnJArray(respond);
   }

◆ getPayloadMetaInfoAsString()

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

inherited

This method finds a payload resource associated to the hash.

This method retrieves metadata of the payload resource. The result is a string. (This method is an analogue of the get_payload_meta_info method in Python)

Parameters

hash - hash.

Returns: JSON as a string with the payload meta info.
See the payload meta info JSON example in CrestClient::getPayloadMetaInfo method.

Definition at line 980 of file CrestApi.cxx.

                                                                          {
     const char* method_name = "CrestClient::getPayloadMetaInfoAsString";
  
     if (m_mode == FILESYSTEM_MODE) {
       return getPayloadMetaInfoAsStringFS(hash);
     }
  
     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 = performRequest(current_path, GET, js, method_name);
  
     return retv;
   }

◆ getPayloadMetaInfoAsStringFS()

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

inherited

This auxillary method finds a payload resource associated to the hash in the local file storage.

This method retrieves metadata of the payload resource. The result is a string. (This method is an analogue of the get_payload_meta_info method in Python)

Parameters

hash - hash.

Returns: JSON as a string with the payload meta info.
See the payload meta info JSON example in CrestClient::getPayloadMetaInfo method.

Definition at line 2572 of file CrestApi.cxx.

                                                                            {
     std::string workDir = m_data_folder;
     workDir += '/';
     workDir += getFirstLetters(hash);
     workDir += '/';
     workDir += hash;
  
     std::string filePath = workDir;
     filePath += "/meta.json";
  
     std::string res = "";
  
     try{
       res = getFileString(filePath);
     }
     catch (...) {
       throw std::runtime_error("ERROR in CrestClient::getPayloadAsStringFS cannot get the payload form file storage.");
     }
  
     return res;
   }

◆ getProxyPath()

void Crest::CrestClient::getProxyPath ( )

privateinherited

Definition at line 3149 of file CrestApi.cxx.

                                 {
     char * val = getenv( m_CREST_PROXY_VAR );
     if (val != NULL){
       m_CREST_PROXY = val;
     }
   }

◆ getResFirst()

nlohmann::json Crest::CrestClient::getResFirst ( nlohmann::json & js )

privateinherited

Auxillary method to get the first element from resources of the new CREST server response.

Parameters

js	- CREST server response.

Definition at line 1922 of file CrestApi.cxx.

                                                         {
     nlohmann::json jNull = getJson("[]");
     nlohmann::json res = js.value("resources", jNull);
     nlohmann::json result;
     try {
       result = res.at(0);
     }
     catch (...) {
       nlohmann::json result0 = nullptr;
       return result0;
     }
     return result;
   }

◆ getResources()

nlohmann::json Crest::CrestClient::getResources ( nlohmann::json & js )

privateinherited

Auxillary method to get a resources parameter from new CREST server response.

Parameters

js	- CREST server response.

Definition at line 1916 of file CrestApi.cxx.

                                                          {
     nlohmann::json js2 = getJson("[]");
     nlohmann::json result = js.value("resources", js2);
     return result;
   }

◆ getSize()

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

inherited

This metghod gets the number of iovs for the given tag.

This method allows to select the count of iovs in a tag. (This method is an analogue of the get_size method in Python)

Parameters

tagname - tag name.

Definition at line 454 of file CrestApi.cxx.

                                                    {
     const char* method_name = "CrestClient::getSize";
  
     if (m_mode == FILESYSTEM_MODE) {
       return getSizeFS(tagname);
     }
  
     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 = performRequest(current_path, GET, js, method_name);
  
  
     nlohmann::json respond = getJson(retv, method_name);
     nlohmann::json res = getResources(respond)[0];
  
     int result = 0;
  
     if (respond.find("size") != respond.end()) {
       int sizeR = respond["size"];
       if (sizeR == 0) return result;
     }
  
     if (res.find("niovs") != res.end()) {
       result = res["niovs"];
     } else {
       throw std::runtime_error("ERROR in CrestClient::getSize CREST Server JSON response has no \"size\" key.");
     }
  
     return result;
   }

◆ getSizeByTagFS()

nlohmann::json Crest::CrestClient::getSizeByTagFS ( const std::string & tagname )

inherited

This method gets the number of iovs for tags matching pattern.

This method allows to select the count of iovs in a tag. This method works with the file storage. (This method is an analogue of the get_size_by_tag method in Python) The result is a JSON object.

Parameters

tagname - tag name.

◆ getSizeFS()

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

inherited

This metghod gets the number of iovs for the given tag.

This method allows to select the count of iovs in a tag. This method works with the file storage. This method works with the file storage. (This method is an analogue of the get_size method in Python)

Parameters

tagname - tag name.

Definition at line 2645 of file CrestApi.cxx.

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

◆ getTagDataInfo()

void Crest::CrestClient::getTagDataInfo ( const std::string & tagname )

inherited

This is an auxillary method for checking how many unique IOVs(hashcodes) are in an IOV list.

It is used to check how many payload files are in the data storage, and how this number corresponds to the unique hashcode number. It works with the file data storage.

Parameters

tagname - tag name.

Definition at line 2712 of file CrestApi.cxx.

                                                            {
     std::cout << std::endl << "test: getTagDataInfo" << std::endl;
  
     try {
       int info = getSizeFS(tagname);
       std::cout << std::endl << "IOV Number (" << tagname << ")       = "
                 << info << std::endl;
     }
     catch (const std::exception& e) {
       std::cout << std::endl << "test: getTagDataInfo (failed)" << std::endl;
       std::cout << e.what() << std::endl;
     }
  
     try {
       nlohmann::json iovList = findAllIovs(tagname);
       int niovs = iovList.size();
       std::list <std::string> hashList;
  
       for (int i = 0; i < niovs; i++) {
         if (iovList[i].find("payloadHash") != iovList[i].end()) {
           std::string hash = iovList[i]["payloadHash"];
           std :: list < std::string > :: iterator pos;
           pos = find(hashList.begin(), hashList.end(), hash);
           if (pos != hashList.end()) {
           } else {
             hashList.push_back(hash);
           }
         }
       }
  
       int hashNumber = hashList.size();
       std::cout << "Hash Number (" << tagname << ")      = "
                 << hashNumber << std::endl;
     }
     catch (const std::exception& e) {
       std::cout << std::endl << "ERROR getTagDataInfo: cannot get IOV List" << std::endl;
       std::cout << e.what() << std::endl;
     }
  
     std::string path = m_root_folder + s_FS_DATA_PATH;
     int dirNumber = 0;
  
     for (auto it : std::filesystem::directory_iterator(path)) {
       dirNumber = dirNumber + 1;
     }
     std::cout << "Directory Number (" << tagname << ") = "
               << dirNumber << std::endl;
   }

◆ getTagMetaInfo()

nlohmann::json Crest::CrestClient::getTagMetaInfo ( const std::string & tagname )

inherited

This method gets a tag meta info from the CREST database.

Parameters

tagname - tag name

Returns: JSON with the tag meta information. Example:

tagMetaInfo(AtlasLayerMat_v16_ATLAS-R1-2012-02)=
  [
    {
     "tagName": "AtlasLayerMat_v16_ATLAS-R1-2012-02",
     "description": "{\"dbname\":\"OFLP200\",\"nodeFullpath\":\"/GLOBAL/TrackingGeo/LayerMaterialV2\",\"schemaName\":\"COOLOFL_GLOBAL\"}",
     "chansize": 1,
     "colsize": 1,
     "tagInfo": "{\"channel_list\":[{\"0\":\"\"}],\"node_description\":\"<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type=\\\"256\\\" clid=\\\"142190734\\\" /></addrHeader><typeName>Trk::LayerMaterialMap</typeName>\",\"payload_spec\":\"PoolRef:String4k\"}",
     "insertionTime": "2023-09-22T12:22:07+0000"
   }
 ]

Tag Meta Info JSON parameters:

tagName        string
description    string
chansize       integer($int32)
colsize        integer($int32)
tagInfo        string
insertionTime  string($date-time)

Definition at line 2037 of file CrestApi.cxx.

                                                                    {
     const char* method_name = "CrestClient::getTagMetaInfo";
  
     if (m_mode == FILESYSTEM_MODE) {
       return getTagMetaInfoFs(tagname);
     }
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
     current_path += '/';
     current_path += tagname;
     current_path += s_META_PATH;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ getTagMetaInfoElement()

std::string Crest::CrestClient::getTagMetaInfoElement	(	const std::string &	name,
		nlohmann::json &	js
	)

inherited

Auxillary method to get an element by name from the Tag Meta Info.

Parameters

name	- an element name.
js	- the Tag Meta Info in JSON format. Example:

  [{"node_description": " string of the folder description "},
   {"channel_list" : [0, 10, 20] },
   {"channel_names: ["first", "second", "third"]},
   {"payload_specification":"stave: Int32, eta: Int32, mag: Float, base: Float, free: Float"}]

Definition at line 1936 of file CrestApi.cxx.

                                                                                       {
     std::string result = "";
     int array_length = js.size();
     for (int i = 0; i < array_length; i++) {
       const nlohmann::json& elem = js[i];
       if (auto itr = elem.find(name); itr != elem.end()) {
         return *itr;
       }
     }
     return result;
   }

◆ getTagMetaInfoFs()

nlohmann::json Crest::CrestClient::getTagMetaInfoFs ( const std::string & name )

inherited

This is an auxillary method, it gets a tag meta info from file system storage.

Parameters

tagname - tag name

Returns: JSON with the tag meta information.
See the tag JSON description in CrestClient::getTagMetaInfo method.

Definition at line 2205 of file CrestApi.cxx.

                                                                   {
     nlohmann::json js = nullptr;
     std::string file_path = m_root_folder;
     file_path += s_FS_TAG_PATH;
     file_path += '/';
     file_path += name;
     file_path += s_FS_TAGMETAINFO_FILE;
     try{
       std::string tag = getFileString(file_path);
       js = nlohmann::json::parse(tag);
     }
     catch (...) {
       throw std::runtime_error(
               "ERROR in CrestClient::getTagMetaInfoFs cannot get the tag meta information form file storage.");
     }
  
     return returnJArray(js);
   }

◆ getTagMetaInfoIOVDbSvc()

nlohmann::json Crest::CrestClient::getTagMetaInfoIOVDbSvc ( const std::string & tagname )

inherited

This method gets a tag meta info from the CREST database in IOVDbSvc format.

Parameters

tagname - tag name

Definition at line 2120 of file CrestApi.cxx.

                                                                            {
     const char* method_name = "CrestClient::updateTagMetaInfo";
  
     checkFsException(method_name);
  
     nlohmann::json js = getTagMetaInfo(tagname);
  
     nlohmann::json resource = js.at(0);
  
     nlohmann::json result = convertTagMetaInfo2IOVDbSvc(resource);
  
     return result;
   }

◆ isJson()

bool Crest::CrestClient::isJson ( const std::string & str )

inherited

This method checks if a string is in the JSON format.

(It is an auxillary method to check the CREST Server response format.)

Parameters

str	- the string to be checked.

Definition at line 1688 of file CrestApi.cxx.

                                                {
     try {
       nlohmann::json js = nlohmann::json::parse(str);
       return true;
     }
     catch (nlohmann::json::parse_error& e) {
       return false;
     }
   }

◆ listFolders()

nlohmann::json Crest::CrestClient::listFolders ( )

inherited

This method returns the folder list on CREST DB.

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

Definition at line 1163 of file CrestApi.cxx.

                                         {
     const char* method_name = "CrestClient::listFolders";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH + s_FOLDER_PATH;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listGlobalTags() [1/2]

nlohmann::json Crest::CrestClient::listGlobalTags ( )

inherited

This method finds a global tag lists.

The result is a JSON object. (This method is an analogue of the list_global_tags method in Python)

Returns: JSON array with the global tag list. Example:

Global tag list =
 [
   {
      "description": "A geometry like global tag",
      "insertionTime": "2023-11-01T08:45:09+0000",
      "insertionTimeMilli": 1698828309000,
      "name": "ATLAS-P2-ITK-22-02-00",
      "release": "1",
      "scenario": "undefined",
      "snapshotTime": "2023-11-01T08:45:09+0000",
      "snapshotTimeMilli": 1698828309000,
      "type": "U",
      "validity": 1,
      "workflow": "undefined"
   },
   ...
 ]

See the single global tag JSON description in CrestClient::findGlobalTag method.

Definition at line 773 of file CrestApi.cxx.

                                            {
     const char* method_name = "CrestClient::listGlobalTags";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_PATH;
     std::string retv;
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, method_name);
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listGlobalTags() [2/2]

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

inherited

This method returns the global tag list.

It is a verion of this method with all parameters.

Parameters

name	- global tag name pattern,
size	- page size,
page	- page number,
sort	- sorting order.

Returns: JSON array with the global tag list.
See the global tag list JSON description in CrestClient::listGlobalTags method.

Definition at line 805 of file CrestApi.cxx.

                                                                                                            {
     const char* method_name = "CrestClient::listGlobalTags";
  
     checkFsException(method_name);
  
     std::string tagname = name;
  
     if (tagname.find("%25") == std::string::npos) {
       replaceSymbols(tagname, "%", "%25");
       replaceSymbols(tagname, "*", "%25");
     }
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_PATH;
     if (!name.empty()) {
       std::string nameString = "?name=";
       nameString += tagname;
       current_path += nameString;
       current_path += "&size=";
       current_path += std::to_string(size);
       current_path += "&page=";
       current_path += std::to_string(page);
       current_path += "&sort=";
       current_path += sort;
     } else {
       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 = performRequest(current_path, GET, js, method_name);
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listGlobalTagsAsString()

std::string Crest::CrestClient::listGlobalTagsAsString ( )

inherited

This method finds a global tag lists.

The rusult is a string. (This method is an analogue of the list_global_tags_as_string method in Python)

Returns: string with the JSON array with the global tag list.
See the global tag list JSON description in CrestClient::listGlobalTags method.

Definition at line 788 of file CrestApi.cxx.

                                                 {
     const char* method_name = "CrestClient::listGlobalTagsAsString";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_PATH;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     return retv;
   }

◆ listPayloadTagInfo() [1/2]

nlohmann::json Crest::CrestClient::listPayloadTagInfo ( )

inherited

This method retrieves monitoring information on all payloads as a list of payload tag information.

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

Returns: JSON array with the payload monitoring tag information. Example:

 payloadTagInfo(TrtCalibT0-MC-run2-run3_00-01)=
 [
    {
       "tagname": "TrtCalibT0-MC-run2-run3_00-01",
       "niovs": 9,
       "totvolume": 63630.0,
       "avgvolume": 7070.0
    }
 ]

JSON parameters:

 tagname     string          tag name
 niovs       integer         number of IOVs
 totvolume   number($float)  total volume
 avgvolume   number($float)  average volume

Definition at line 1023 of file CrestApi.cxx.

                                                {
     const char* method_name = "CrestClient::getPayloadTagInfo";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_MONITORING_PAYLOAD_PATH;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listPayloadTagInfo() [2/2]

nlohmann::json Crest::CrestClient::listPayloadTagInfo ( const std::string & tagname )

inherited

This method retrieves monitoring information on payload as a list of payload tag information.

(This method is an analogue of the list_payload_tag_info method in Python) @params tagname - tag name.

Returns: JSON array with the payload monitoring tag information.
See CrestClient::listPayloadTagInfo method.

Definition at line 1002 of file CrestApi.cxx.

                                                                        {
     const char* method_name = "CrestClient::getPayloadTagInfo";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_MONITORING_PAYLOAD_PATH;
     current_path += "?tagname=";
     current_path += tagname;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listRunLumiInfo()

nlohmann::json Crest::CrestClient::listRunLumiInfo ( )

inherited

This method gets full list of run/lumi information data.

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

Definition at line 1198 of file CrestApi.cxx.

                                             {
     const char* method_name = "CrestClient::listRunLumiInfo";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH + s_RUNINFO_PATH;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listTags() [1/3]

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

inherited

This method returns the tag list.

It is a verion of this method with all parameters. (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.

Returns: JSON array with the tag list.
See the taglist JSON description in CrestClient::listTags method.

Definition at line 167 of file CrestApi.cxx.

                                                                                                      {
     const char* method_name = "CrestClient::listTags";
  
     checkFsException(method_name);
  
     std::string tagname = name;
  
     if (tagname.find("%25") == std::string::npos) {
       replaceSymbols(tagname, "%", "%25");
       replaceSymbols(tagname, "*", "%25");
     }
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
  
     if (!name.empty()) {
       std::string nameString = "?name=";
       nameString += tagname;
       current_path += nameString;
       current_path += "&size=";
       current_path += std::to_string(size);
       current_path += "&page=";
       current_path += std::to_string(page);
       current_path += "&sort=";
       current_path += sort;
     } else {
       current_path += "?size=";
       current_path += std::to_string(size);
       current_path += "&page=";
       current_path += std::to_string(page);
       current_path += "&sort=";
       current_path += sort;
     }
  
     nlohmann::json js = nullptr;
     std::string retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listTags() [2/3]

nlohmann::json Crest::CrestClient::listTags	(	int	size,
		int	page
	)

inherited

This method returns the tag list.

It is a verion of this method with additional parameters. (This method is an analogue of the list_tags method in Python)

Parameters

size	- page size.
page	- page number.

Returns: JSON array with the tag list.
See the taglist JSON description in CrestClient::listTags method.

Definition at line 121 of file CrestApi.cxx.

                                                        {
     const char* method_name = "CrestClient::listTags";
  
     checkFsException(method_name);
  
     int size_default = 1000;
     int page_default = 0;
     std::string size_param = "";
     std::string page_param = "";
     std::string params = "";
  
     if (size == size_default && page == page_default) {
       nlohmann::json respond = listTags();
       return getResources(respond);
     }
  
     if (size != size_default) {
       size_param = "size=";
       size_param += std::to_string(size);
       params += size_param;
     }
     if (page != page_default) {
       page_param = "page=";
       page_param += std::to_string(page);
       if (page_param.empty()) {
         params += page_param;
       } else {
         params += '&';
         params += page_param;
       }
     }
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
     current_path += '?';
     current_path += params;
     std::string retv;
  
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ listTags() [3/3]

nlohmann::json Crest::CrestClient::listTags ( void )

inherited

This method returns the tag list.

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

Returns: JSON array with the tag list. Example:

[
   {
       "description": "A new tag for testing",
       "endOfValidity": 0,
       "insertionTime": "2023-04-27T18:51:44+0000",
       "lastValidatedTime": -1,
       "modificationTime": "2023-10-27T13:05:38+0000",
       "name": "A-TEST-TAG-03",
       "payloadSpec": "JSON",
       "synchronization": "any",
       "timeType": "time"
   },
 ...
]

See the single tag JSON description in CrestClient::findTag method.

Definition at line 103 of file CrestApi.cxx.

                                      {
     const char* method_name = "CrestClient::listTags";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ make_url()

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

privateinherited

Definition at line 90 of file CrestApi.cxx.

                                                               {
   std::string str("http://");
   str += m_host;
   str += ':';
   str += m_port;
   str += address;
   return str;
 }

◆ ParseXMLOutput()

std::string Crest::CrestClient::ParseXMLOutput ( std::string_view xmlBuffer )

privateinherited

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

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

Parameters

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

Definition at line 1656 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;
   }

◆ performRequest() [1/3]

std::string Crest::CrestClient::performRequest	(	const std::string &	current_path,
		Action	action,
		nlohmann::json &	js
	)

privateinherited

General auxiliary method to make request to the CREST Server.

This method is used by other methods realizing the requests with the concrete kinds of data (iovs|payloads|tags…).

Parameters

current_path	- URL request path
action	- Action (GET\|POST\|DELETE)
js	- a JSON object which has to be send or changed with this request. If this argument has to be void it has to be set as nullptr.

Definition at line 1366 of file CrestApi.cxx.

                                                                                                       {
     const char* method = "Unknown";
  
     return performRequest(current_path, action, js, method);
   }

◆ performRequest() [2/3]

std::string Crest::CrestClient::performRequest	(	const std::string &	current_path,
		Action	action,
		nlohmann::json &	js,
		const char *	method_name
	)

privateinherited

General auxillary method to make request to the CREST Server.

This method is used by other methods realizing the requests with the concrete kinds of data (iovs|payloads|tags…).

Parameters

current_path	- URL request path
action	- Action (GET\|POST\|DELETE)
js	- a JSON object which has to be send or changed with this request. If this argument has to be void it has to be set as nullptr.
method_name	- the name of method which called this method. This parameter is used in the error messages.

Definition at line 1289 of file CrestApi.cxx.

                                                                    {
     CURL* curl;
     CURLcode res;
  
  
     /* Enable tracing of ascii data */
     //sanitise the current path
     std::string sanitisedPath(current_path);
     auto caretPosition = sanitisedPath.find('^');
     if (caretPosition != std::string::npos) sanitisedPath.replace(caretPosition, 1, "%5E");
     /* get a curl handle */
     curl = curl_easy_init();
     std::string stt;
     struct curl_slist* headers = NULL;
     if (curl) {
       std::string url = make_url(sanitisedPath);
       std::string s;
       std::cout << "cURL request to " << url << std::endl;
  
      if (m_CREST_PROXY) {
        // The environment variable exists, and 'socksProxy' now contains its value
        std::cout << "SOCKS proxy: " << m_CREST_PROXY << std::endl;
        // Set the proxy type (replace with your proxy type details)
        curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
  
        // Set the proxy address and port (replace with your SOCKS proxy details)
        curl_easy_setopt(curl, CURLOPT_PROXY, m_CREST_PROXY);
       }
  
       curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
       if (js.is_null()) {
         if (action == DELETE) curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
       } else {
         stt = js.dump();
  
         if (action == PUT) curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
         headers = curl_slist_append(headers, "Accept: */*");
         headers = curl_slist_append(headers, "Content-Type: application/json");
  
         headers = curl_slist_append(headers, "Expect:");
         curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
         curl_easy_setopt(curl, CURLOPT_POST, 1L);
  
         /* set where to read from (on Windows you need to use READFUNCTION too) */
         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, stt.c_str());
       }
  
       curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWrite_CallbackFunc_StdString);
       curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s);
  
  
       /* Perform the request, res will get the return code */
       res = curl_easy_perform(curl);
  
  
       // data to check the errors in the server response:
       long response_code;
       curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
  
       /* always cleanup */
       curl_easy_cleanup(curl);
       curl_slist_free_all(headers);
  
       curl_global_cleanup();
  
       // error checking in the server response:
       checkResult(res, response_code, s, method_name);
  
       return s;
     }
  
     throw std::runtime_error(std::string("ERROR in ") + std::string(method_name) + " | CURL not init");
   }

◆ performRequest() [3/3]

std::string Crest::CrestClient::performRequest	(	const std::string &	current_path,
		Action	action,
		nlohmann::json &	js,
		std::ofstream &	out
	)

privateinherited

General auxillary method to make request to the CREST Server.

This method used to get a Blob as a stream. See method getBlobInStream(std::string& hash, std::ofstream& out).

Parameters

current_path	- URL request path
action	- Action (GET\|POST\|DELETE)
js	- a JSON object which has to be send or changed with this request. If this argument has to be void it has to be set as nullptr.
out	- stream to get the result

Definition at line 1378 of file CrestApi.cxx.

                                                             {
     boost::asio::streambuf response;
     boost::asio::io_service io_service;
  
     try {
       // Get a list of endpoints corresponding to the server name.
       boost::asio::ip::tcp::resolver resolver(io_service);
       boost::asio::ip::tcp::resolver::query query(m_host, m_port, boost::asio::ip::resolver_query_base::flags());
       boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
  
       // Try each endpoint until we successfully establish a connection.
       boost::asio::ip::tcp::socket socket(io_service);
       boost::asio::connect(socket, endpoint_iterator);
  
       std::string retv = "Invalid response\n";
  
       boost::asio::streambuf request;
       std::ostream request_stream(&request);
  
       std::string cmd_line = "";
       if      (action == GET)    cmd_line = "GET";
       else if (action == PUT)    cmd_line = "PUT";
       else if (action == DELETE) cmd_line = "DELETE";
  
       if (js.is_null()) {
         request_stream << cmd_line  << " " << current_path << " HTTP/1.0\r\n";
         request_stream << "Host: " << m_host << ':' << m_port << " \r\n"; 
         request_stream << "Accept: */*\r\n";
         request_stream << "Connection: close\r\n\r\n";
       } else {
         std::string s = js.dump();
         request_stream << action << " " << current_path << " HTTP/1.0\r\n"; 
         request_stream << "Host: " << m_host << ':' << m_port << " \r\n";
         request_stream << "Content-Type: application/json; \r\n";
         request_stream << "Accept: */*\r\n";
         request_stream << "Content-Length: " << s.length() << "\r\n";
         request_stream << "Connection: close\r\n\r\n";
         request_stream << s;
       }
  
  
       //begin request
  
       // Send the request.
       boost::asio::write(socket, request);
  
       // Read the response status line. The response streambuf will automatically
       // grow to accommodate the entire line. The growth may be limited by passing
       // a maximum size to the streambuf constructor.
  
       boost::asio::read_until(socket, response, "\r\n");
  
  
  
       boost::asio::read_until(socket, response, "\r\n");
  
       // Check that response is OK.
       std::istream response_stream(&response);
       std::string http_version;
       response_stream >> http_version;
       unsigned int status_code;
       response_stream >> status_code;
  
       std::string status_message;
       std::getline(response_stream, status_message);
  
  
       if (!response_stream || http_version.substr(0, 5) != "HTTP/") {
         std::cout << "Invalid response" << std::endl;
     std::cout << "response_stream : " << status_code << std::endl; // new
         return retv;
       }
       if (status_code != 200) {
         std::cout << "Response returned with status code " << status_code << std::endl;
  
         return retv;
       }
  
       // Read the response headers, which are terminated by a blank line.
       boost::asio::read_until(socket, response, "\r\n\r\n");
  
       // Process the response headers.
       std::string header;
       while (std::getline(response_stream, header) && header != "\r") {
         std::cout << header << std::endl;
       }
       std::cout << std::endl;
   
       std::ostringstream txt;
  
       // Write whatever content we already have to output.
       if (response.size() > 0) out << &response;
  
  
       // Read until EOF, writing data to output as we go.
       boost::system::error_code error;
       while (boost::asio::read(socket, response,
                                boost::asio::transfer_at_least(1), error))
         out << &response;
  
       if (error != boost::asio::error::eof) {
         std::cerr << "connection error" << std::endl;
         std::string st0 = "";
         return st0;
       }
  
       retv = status_code;
       return retv;
  
       //end request
     }
     catch (boost::system::system_error& e) {
       std::cerr << e.what() << " | " << e.code() << std::endl;
       std::string st0 = "";
       return st0;
     }
     catch (...) {
       std::cerr << "connection error" << std::endl;
       std::string st0 = "";
       return st0;
     }
   }

◆ removeCR()

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

privateinherited

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

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

Parameters

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

Definition at line 1677 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 )

inherited

This method allows to remove a Global Tag form CREST DB.

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

Parameters

name	- global tag name

Definition at line 758 of file CrestApi.cxx.

                                                          {
     const char* method_name = "CrestClient::removeGlobalTag";
  
     checkFsException(method_name);
  
     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 = performRequest(current_path, DELETE, js, method_name);
   }

◆ removeTag()

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

inherited

This method allows to remove a Tag.

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

Parameters

tagName - tag name

Definition at line 209 of file CrestApi.cxx.

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

◆ removeTagFromGlobalTagMap()

void Crest::CrestClient::removeTagFromGlobalTagMap	(	const std::string &	global_tag,
		const std::string &	tag,
		const std::string &	label
	)

inherited

This method removes a tag with the name tag and the label from the global tag map with name global_tag.

Parameters

global_tag	- global tag name.
tag	- tag name.
label	- tag label in the global tag map.

Definition at line 2902 of file CrestApi.cxx.

                                                                                                                      {
  
     const char* method_name = "CrestClient::removeTagFromGlobalTagMap";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_GLOBALTAG_MAP_PATH;
     current_path += '/';
     current_path += global_tag;
     current_path += '?';
     current_path += "tagname=";
     current_path += tag;
     current_path += "&label=";
     current_path += label;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, DELETE, js, method_name);
   }

◆ replaceSymbols()

void Crest::CrestClient::replaceSymbols	(	std::string &	str,
		const std::string &	from,
		const std::string &	to
	)

inherited

This auxilary method replaces the substring from by the substring to.

Parameters

str	- the string, where it is necessary to replace a substring.
from	- the substring to be replaced.
to	- the new substring to replace to replace the old one.

Definition at line 3156 of file CrestApi.cxx.

                                                     {
     size_t pos = 0;
     while((pos = subject.find(search, pos)) != std::string::npos) {
          subject.replace(pos, search.length(), replace);
          pos += replace.length();
     }
   }

◆ returnJArray()

nlohmann::json Crest::CrestClient::returnJArray ( nlohmann::json js )

inherited

This auxillary method creates a JSON array from a JSON object.

It used to convert a single objects (such as tags and global tags to JSON array in methods which retrive the data from a file starage.

Parameters

js	- JSON object.

Definition at line 2639 of file CrestApi.cxx.

                                                         {
     nlohmann::json result = nlohmann::json::array();
     result.push_back(js);
     return result;
   }

◆ selectGroups() [1/2]

nlohmann::json Crest::CrestClient::selectGroups ( const std::string & tagname )

inherited

Select groups for a given tagname.

This method allows to select a list of groups. The result is a JSON object. (This method is an analogue of the select_groups method in Python)

Parameters

tagname - tag name.

Definition at line 579 of file CrestApi.cxx.

                                                                  {
     const char* method_name = "CrestClient::selectGroups";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
  
     current_path += "?method=";
     current_path += s_METHOD_GROUPS;
     current_path += "&tagname=";
  
     current_path += tagname;
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ selectGroups() [2/2]

nlohmann::json Crest::CrestClient::selectGroups	(	const std::string &	tagname,
		long	snapshot
	)

inherited

Select groups for a given tagname.

This method allows to select a list of groups. The result is a JSON object. (This method is an analogue of the select_groups method in Python)

Parameters

tagname	- tag name.
snapshot	- snapshot.

Definition at line 604 of file CrestApi.cxx.

                                                                                 {
     const char* method_name = "CrestClient::selectGroups";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
  
     current_path += "?method=";
     current_path += s_METHOD_GROUPS;
     current_path += "&tagname=";
  
     current_path += tagname;
     current_path += "&snapshot=";
     current_path += std::to_string(snapshot); 
  
     std::string retv;
  
     nlohmann::json js = nullptr;
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ selectIovs() [1/3]

nlohmann::json Crest::CrestClient::selectIovs ( const std::string & tagname )

inherited

Select iovs for a given tagname.

This method allows to select a list of iovs in a tag for a given snapshot time. The result is a JSON object. (This method is an analogue of the select_iovs method in Python)

Parameters

tagname	- tag name.
snapshot	- snapshot.

Returns: JSON array with the IOV list.
See the IOV list JSON description in CrestClient::findAllIovs method.

Definition at line 493 of file CrestApi.cxx.

                                                                {
     const char* method_name = "CrestClient::selectIovs";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
     current_path += "?method=";
     current_path += s_METHOD_IOVS;
     current_path += "&tagname=";
  
     current_path += tagname; 
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ selectIovs() [2/3]

nlohmann::json Crest::CrestClient::selectIovs	(	const std::string &	tagname,
		long	since,
		long	until,
		long	snapshot = `0`
	)

inherited

This method selects all iovs for a given tag name and for the selected time interval (since-until).

The result is a JSON array. It is a verion of this method with all parameters. This method works with the CREST server. If until=-1 it means until is infinity, in this case "until=INF" in the URL request.

Parameters

tagname	- tag name.
since	- start time.
until	- end time.
snapshot	- snapshot (the default value is 0)

Returns: JSON array with the IOV list.
See the IOV list JSON description in CrestClient::findAllIovs method.

Definition at line 544 of file CrestApi.cxx.

                                                                                                       {
     const char* method_name = "CrestClient::selectIovs";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
  
     current_path += "?method=";
     current_path += s_METHOD_IOVS;
     current_path += "&tagname=";
  
     current_path += tagname;
     current_path += "&since=";
     current_path += std::to_string(since);
     current_path += "&until=";
     if (until == -1) {
       current_path += "INF";
     } else {
       current_path += std::to_string(until);
     }
     current_path += "&snapshot=";
     current_path += std::to_string(snapshot);
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ selectIovs() [3/3]

nlohmann::json Crest::CrestClient::selectIovs	(	const std::string &	tagname,
		long	snapshot
	)

inherited

Select iovs for a given tagname.

This method allows to select a list of iovs in a tag for a given snapshot time. The result is a JSON object. (This method is an analogue of the select_iovs method in Python)

Parameters

tagname	- tag name.
snapshot	- snapshot.

Returns: JSON array with the IOV list.
See the IOV list JSON description in CrestClient::findAllIovs method.

Definition at line 517 of file CrestApi.cxx.

                                                                               {
     const char* method_name = "CrestClient::selectIovs";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
  
     current_path += "?method=";
     current_path += s_METHOD_IOVS;
     current_path += "&tagname=";
  
     current_path += tagname;
     current_path += "&snapshot=";
     current_path += std::to_string(snapshot); 
  
     std::string retv;
  
     nlohmann::json js = nullptr;
  
     retv = performRequest(current_path, GET, js, method_name);
  
     nlohmann::json respond = getJson(retv, method_name);
  
     return getResources(respond);
   }

◆ selectIovsFS()

nlohmann::json Crest::CrestClient::selectIovsFS	(	const std::string &	tagname,
		long	since,
		long	until
	)

inherited

This method selects all iovs for a given tag name and for the selected time interval (since-until).

The result is a JSON array. It is a verion of this method with all parameters. This method works with the file storage. If until=-1 it means until is infinity, in this case "until=INF" in the URL request.

Parameters

tagname	- tag name.
since	- start time.
until	- end time.

Returns: JSON array with the IOV list.
See the IOV list JSON description in CrestClient::findAllIovs method.

Definition at line 2689 of file CrestApi.cxx.

                                                                                          {
     nlohmann::json js = nlohmann::json::array();
  
     try{
       nlohmann::json iovList = findAllIovsFs(tagname);
       int niovs = iovList.size();
       for (int i = 0; i < niovs; i++) {
         if (iovList[i].find("since") != iovList[i].end()) {
           ;
           long currentS = iovList[i]["since"];
           if (currentS >= since && currentS <= until) {
             js.push_back(iovList[i]);
           }
         }
       }
     }
     catch (...) {
       throw std::runtime_error("ERROR in CrestClient::selectIovsFS : cannot get the iov list form file storage");
     }
  
     return js;
   }

◆ shortListTagsFs()

std::list< std::string > Crest::CrestClient::shortListTagsFs ( )

inherited

This method returns a tag list stored in the file storage.

This is the auxilary method. The result is the tag names only (as a string list). (The old name of this method is short_list_tags_fs)

Definition at line 1749 of file CrestApi.cxx.

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

◆ split()

std::vector< std::string > Crest::CrestClient::split	(	std::string_view	str,
		char	delim
	)

privateinherited

Auxillary method to split a string.

Parameters

str	- a string to split.
delim	- a deliminator.

Definition at line 1982 of file CrestApi.cxx.

                                                                         {
     std::vector<std::string> tokens;
     std::size_t prev = 0, pos = 0;
     do {
       pos = str.find(delim, prev);
       if (pos == std::string::npos) pos = str.length();
       std::string_view token = str.substr(prev, pos - prev);
       if (!token.empty()) tokens.emplace_back(token);
       prev = pos + 1;
     } while (pos < str.length() && prev < str.length());
     return tokens;
   }

◆ storeBatchIOVs()

void Crest::CrestClient::storeBatchIOVs ( nlohmann::json & js )

inherited

This method stores an IOV set on the CREST server.

The IOVs are send as a JSON array.

Parameters

js	- IOV set.

Definition at line 630 of file CrestApi.cxx.

                                                    {
     const char* method_name = "CrestClient::storeBatchIOVs";
  
     checkFsException(method_name);
  
     /*
  
        Request Example:
  
        curl -H "Accept: application/json" -H "Content-Type: application/json"  -X POST
           http://crest-02.cern.ch:8090/crestapi/iovs/storebatch
        -d '{"size": 2, "datatype": "iovs", "format": "IovSetDto","resources":
        [
        {"payloadHash": "9834876dcfb05cb167a5c24953eba58c4ac89b1adf57f28f2f9d09af107ee8f0","since": 200,"tagName":
           "test_MvG10"},
        {"payloadHash": "3e744b9dc39389baf0c5a0660589b8402f3dbb49b89b3e75f2c9355852a3c677","since": 250,"tagName":
           "test_MvG10"}
        ]
        }'
      */
  
     int n = js.size();
  
     nlohmann::json arg =
     {
       {"size", n},
       {"datatype", "iovs"},
       {"format", "IovSetDto"},
       {"resources", js}
     };
  
  
     std::string current_path = m_PATH;
     current_path += s_IOV_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, POST, arg, method_name);
   }

◆ storeBatchPayloadFilesRequest()

std::string Crest::CrestClient::storeBatchPayloadFilesRequest	(	const std::string &	tag,
		uint64_t	endtime,
		const std::string &	js
	)

inherited

This is an auxilary method to make an request to store several payloads from files in the batch mode.

Parameters

tag	- tag name.
endtime	- end time.
js	- payloads in the JSON format.

Definition at line 2948 of file CrestApi.cxx.

                                                                                                                   {
     std::string current_path = m_PATH;
     current_path += s_PAYLOAD_PATH;
  
     nlohmann::json json0 = getJson(js);
     nlohmann::json resources = nullptr;
     
     auto subjectIdIter1 = json0.find("resources");
     if (subjectIdIter1 != json0.end()){
      resources = json0["resources"];
     }
  
     int partN = resources.size();
  
     CURL* curl;
     CURLcode res;
  
     // get a curl handle
  
     curl_global_init(CURL_GLOBAL_DEFAULT);
     curl = curl_easy_init();
  
     struct curl_slist* headers = NULL;
     if (curl) {
       std::string url = make_url(current_path);
       std::string s;
  
      if (m_CREST_PROXY) {
        // The environment variable exists, and 'socksProxy' now contains its value
        std::cout << "SOCKS proxy: " << m_CREST_PROXY << std::endl;
        // Set the proxy type (replace with your proxy type details)
        curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
  
        // Set the proxy address and port (replace with your SOCKS proxy details)
        curl_easy_setopt(curl, CURLOPT_PROXY, m_CREST_PROXY);
       }
  
       // First set the URL that is about to receive our POST. This URL can
       // just as well be a https:
       // URL if that is what should receive the data.
  
       curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
  
       headers = curl_slist_append(headers, "X-Crest-PayloadFormat: FILE"); // MvG
       headers = curl_slist_append(headers, "Accept: */*");
       headers = curl_slist_append(headers, "Content-Type:  multipart/form-data");
  
       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  
       // Create the form  for new version
 #if LIBCURL_VERSION_MAJOR < 8
       struct curl_httppost* formpost = NULL;
       struct curl_httppost* lastptr = NULL;
       curl_formadd(&formpost,
                    &lastptr,
                    CURLFORM_COPYNAME, "tag",
                    CURLFORM_COPYCONTENTS, tag.c_str(),
                    CURLFORM_END);
 #else
       curl_mime* mime = curl_mime_init(curl);
       {
         curl_mimepart* part = curl_mime_addpart(mime);
         curl_mime_name(part, "tag");
         curl_mime_data(part, tag.c_str(), tag.size());
       }
 #endif
       if (endtime != 0) {
 #if LIBCURL_VERSION_MAJOR < 8
         curl_formadd(&formpost,
                      &lastptr,
                      CURLFORM_COPYNAME, "endtime",
                      CURLFORM_COPYCONTENTS, std::to_string(endtime).c_str(),
                      CURLFORM_END);
 #else
         std::string endtime_s = std::to_string(endtime);
         curl_mimepart* part = curl_mime_addpart(mime);
         curl_mime_name(part, "endtime");
         curl_mime_data(part, endtime_s.c_str(), endtime_s.size());
 #endif
       }
 #if LIBCURL_VERSION_MAJOR < 8
       curl_formadd(&formpost,
                    &lastptr,
                    CURLFORM_COPYNAME, "storeset",
                    CURLFORM_COPYCONTENTS, js.c_str(),
                    CURLFORM_END);
  
       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);
  
        curl_formadd(&formpost, &lastptr,
      CURLFORM_COPYNAME, "files",
      CURLFORM_FILE, data_file.c_str(),
          CURLFORM_END);
  
       } // i
  
       curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
 #else
       {
         curl_mimepart* part = curl_mime_addpart(mime);
         curl_mime_name(part, "storeset");
         curl_mime_data(part, js.c_str(), js.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);
  
     { 
         curl_mimepart* part = curl_mime_addpart(mime);
         curl_mime_name(part, "files");
         curl_mime_filedata(part, data_file.c_str());
         }
  
       } // i
       
       curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
 #endif
  
       curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWrite_CallbackFunc_StdString);
       curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s);
  
       // Perform the request, res will get the return code
       res = curl_easy_perform(curl);
  
       // data to check the errors in the server response:
       long response_code;
       curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
       const char* method_name = "CrestClient::storeBatchPayloads";
  
       /* always cleanup */
       curl_easy_cleanup(curl);
 #if LIBCURL_VERSION_MAJOR < 8
       curl_formfree(formpost);
       curl_slist_free_all(headers);
 #else
       curl_slist_free_all(headers);
       curl_mime_free(mime);
 #endif
  
       curl_global_cleanup();
  
       // error checking in the server response:
       checkResult(res, response_code, s, method_name);
  
       return s;
     }
     std::string mes = "ERROR in CrestClient::storeBatchPayloads";
     throw std::runtime_error(mes + " | CURL not init");
   }

◆ storeBatchPayloadRequest()

std::string Crest::CrestClient::storeBatchPayloadRequest	(	const std::string &	tag,
		uint64_t	endtime,
		const std::string &	js
	)

privateinherited

This is an auxillary method to make an request to store several payloads in the batch mode.

(The old method name - store_batch_payload_request)

Parameters

tag	- tag name.
endtime	- end time.
js	- payloads in the JSON format.

Definition at line 1505 of file CrestApi.cxx.

                                                                                                              {
     std::string current_path = m_PATH;
     current_path += s_PAYLOAD_PATH;
  
     CURL* curl;
     CURLcode res;
  
     // get a curl handle
  
     curl_global_init(CURL_GLOBAL_DEFAULT);
     curl = curl_easy_init();
  
     struct curl_slist* headers = NULL;
     if (curl) {
       std::string url = make_url(current_path);
       std::string s;
  
       if (m_CREST_PROXY) {
        // The environment variable exists, and 'socksProxy' now contains its value
        std::cout << "SOCKS proxy: " << m_CREST_PROXY << std::endl;
        // Set the proxy type (replace with your proxy type details)
        curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
  
        // Set the proxy address and port (replace with your SOCKS proxy details)
        curl_easy_setopt(curl, CURLOPT_PROXY, m_CREST_PROXY);
       }
  
       // First set the URL that is about to receive our POST. This URL can
       // just as well be a https:
       // URL if that is what should receive the data.
  
       curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
       headers = curl_slist_append(headers, "X-Crest-PayloadFormat: JSON");
       headers = curl_slist_append(headers, "Accept: */*");
       headers = curl_slist_append(headers, "Content-Type:  multipart/form-data");
  
       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  
       // Create the form  for new version
 #if LIBCURL_VERSION_MAJOR < 8
       struct curl_httppost* formpost = NULL;
       struct curl_httppost* lastptr = NULL;
       curl_formadd(&formpost,
                    &lastptr,
                    CURLFORM_COPYNAME, "tag",
                    CURLFORM_COPYCONTENTS, tag.c_str(),
                    CURLFORM_END);
 #else
       curl_mime* mime = curl_mime_init(curl);
       {
         curl_mimepart* part = curl_mime_addpart(mime);
         curl_mime_name(part, "tag");
         curl_mime_data(part, tag.c_str(), tag.size());
       }
 #endif
       if (endtime != 0) {
 #if LIBCURL_VERSION_MAJOR < 8
         curl_formadd(&formpost,
                      &lastptr,
                      CURLFORM_COPYNAME, "endtime",
                      CURLFORM_COPYCONTENTS, std::to_string(endtime).c_str(),
                      CURLFORM_END);
 #else
         std::string endtime_s = std::to_string(endtime);
         curl_mimepart* part = curl_mime_addpart(mime);
         curl_mime_name(part, "endtime");
         curl_mime_data(part, endtime_s.c_str(), endtime_s.size());
 #endif
       }
 #if LIBCURL_VERSION_MAJOR < 8
       curl_formadd(&formpost,
                    &lastptr,
                    CURLFORM_COPYNAME, "storeset",
                    CURLFORM_COPYCONTENTS, js.c_str(),
                    CURLFORM_CONTENTTYPE, "application/json",
                    CURLFORM_END);
       curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
 #else
       {
         curl_mimepart* part = curl_mime_addpart(mime);
         curl_mime_name(part, "storeset");
         curl_mime_type(part, "application/json");
         curl_mime_data(part, js.c_str(), js.size());
       }
       curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
 #endif
  
       curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWrite_CallbackFunc_StdString);
       curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s);
  
       // Perform the request, res will get the return code
       res = curl_easy_perform(curl);
  
       // data to check the errors in the server response:
       long response_code;
       curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
       const char* method_name = "CrestClient::storeBatchPayloads";
  
       /* always cleanup */
       curl_easy_cleanup(curl);
 #if LIBCURL_VERSION_MAJOR < 8
       curl_formfree(formpost);
       curl_slist_free_all(headers);
 #else
       curl_slist_free_all(headers);
       curl_mime_free(mime);
 #endif
  
       curl_global_cleanup();
  
       // error checking in the server response:
       checkResult(res, response_code, s, method_name);
  
       return s;
     }
     std::string mes = "ERROR in CrestClient::storeBatchPayloads";
     throw std::runtime_error(mes + " | CURL not init");
   }

◆ storeBatchPayloads() [1/4]

void Crest::CrestClient::storeBatchPayloads	(	const std::string &	tag_name,
		const std::string &	iovsetupload,
		uint64_t	endtime = `0`
	)

inherited

This method stores several payloads in batch mode.

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

Parameters

tag_name	- tag name.
endtime	- end time, if endtime = 0, the server does not use this parameter in the internal check.
iovsetupload	- iov data as a string.

Example how to use these parameters:

  std::string name58 = "test_MvG3b";
  uint64_t endtime58 = 200;
  std::string str58 = "[{\"data\":\"aaa\",\"since\":100},{\"data\":\"bbb\",\"since\":150}]";
  myCrestClient.storeBatchPayloads(name58, endtime58, str58);

Definition at line 1131 of file CrestApi.cxx.

                                                                                                                  {
     const char* method_name = "CrestClient::storeBatchPayloads";
  
     nlohmann::json js = getJson(iovsetupload, method_name);
     storeBatchPayloads(tag_name, endtime, js);
   }

◆ storeBatchPayloads() [2/4]

void Crest::CrestClient::storeBatchPayloads	(	const std::string &	tag_name,
		nlohmann::json &	js,
		uint64_t	endtime = `0`
	)

inherited

This method stores several payloads in batch mode.

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

Parameters

tag_name	- tag name.
endtime	- end time, if endtime = 0, the server does not use this parameter in the internal check.
iovsetupload	- iov data as a JSON object.

Example how to use these parameters:

  std::string name58 = "test_MvG3a";
  uint64_t endtime58 = 200;
  std::string str58 = "[{\"data\":\"aaa\",\"since\":100},{\"data\":\"bbb\",\"since\":150}]";
  nlohmann::json js58 = myCrestClient.getJson(str58);
  myCrestClient.storeBatchPayloads(name58, endtime58, js58)

Definition at line 1138 of file CrestApi.cxx.

                                                                                                     {
     const char* method_name = "CrestClient::storeBatchPayloads";
  
     if (m_mode == FILESYSTEM_MODE) {
       storeBatchPayloadsFs(tag_name, js);
       return;
     }
     if (!js.is_array()) {
       throw std::runtime_error("ERROR in " + std::string(method_name) + " JSON has wrong type (must be array)");
     }
  
     nlohmann::json jsObj = {};
     jsObj["datatype"] = "iovs";
     jsObj["format"] = "StoreSetDto";
     jsObj["size"] = js.size();
     jsObj["resources"] = js;
     std::string str = jsObj.dump();
     std::string retv = storeBatchPayloadRequest(tag_name, endtime, str);
  
     nlohmann::json respond = getJson(retv, method_name);
   }

◆ storeBatchPayloads() [3/4]

void Crest::CrestClient::storeBatchPayloads	(	const std::string &	tag_name,
		uint64_t	endtime,
		const std::string &	iovsetupload
	)

inherited

This method stores several payloads in batch mode.

(The deprecated method.) (This method is an analogue of the store_batch_payloads method in Python)

Parameters

tag_name	- tag name.
endtime	- end time.
iovsetupload	- iov data as a string.

Example how to use these parameters:

  std::string name58 = "test_MvG3b";
  uint64_t endtime58 = 200;
  std::string str58 = "[{\"data\":\"aaa\",\"since\":100},{\"data\":\"bbb\",\"since\":150}]";
  myCrestClient.storeBatchPayloads(name58, endtime58, str58);

Definition at line 1102 of file CrestApi.cxx.

                                                                                                                  {
     const char* method_name = "CrestClient::storeBatchPayloads";
  
     nlohmann::json js = getJson(iovsetupload, method_name);
     storeBatchPayloads(tag_name, endtime, js);
   }

◆ storeBatchPayloads() [4/4]

void Crest::CrestClient::storeBatchPayloads	(	const std::string &	tag_name,
		uint64_t	endtime,
		nlohmann::json &	js
	)

inherited

This method stores several payloads in batch mode.

(The deprecated method.) (This method is an analogue of the store_batch_payloads method in Python)

Parameters

tag_name	- tag name.
endtime	- end time.
iovsetupload	- iov data as a JSON object.

Example how to use these parameters:

  std::string name58 = "test_MvG3a";
  uint64_t endtime58 = 200;
  std::string str58 = "[{\"data\":\"aaa\",\"since\":100},{\"data\":\"bbb\",\"since\":150}]";
  nlohmann::json js58 = myCrestClient.getJson(str58);
  myCrestClient.storeBatchPayloads(name58, endtime58, js58)

Definition at line 1109 of file CrestApi.cxx.

                                                                                                     {
     const char* method_name = "CrestClient::storeBatchPayloads";
  
     if (m_mode == FILESYSTEM_MODE) {
       storeBatchPayloadsFs(tag_name, js);
       return;
     }
     if (!js.is_array()) {
       throw std::runtime_error("ERROR in " + std::string(method_name) + " JSON has wrong type (must be array)");
     }
  
     nlohmann::json jsObj = {};
     jsObj["datatype"] = "iovs";
     jsObj["format"] = "StoreSetDto";
     jsObj["size"] = js.size();
     jsObj["resources"] = js;
     std::string str = jsObj.dump();
     std::string retv = storeBatchPayloadRequest(tag_name, endtime, str);
  
     nlohmann::json respond = getJson(retv, method_name);
   }

◆ storeBatchPayloadsFiles()

void Crest::CrestClient::storeBatchPayloadsFiles	(	const std::string &	tag_name,
		uint64_t	endtime,
		nlohmann::json &	js
	)

inherited

This method stores several payloads from files in batch mode.

(The deprecated method.)

Parameters

tag_name	- tag name.
endtime	- end time.
js	- iov data as a JSON object.

Example how to use these parameters:

  std::string file1 = "/tmp/mvg01.txt";
  std::string file2 = "/tmp/mvg02.txt";
  std::string d1 = "file://" + file1;
  std::string d2 = "file://" + file2;

  std::string str = "[{\"data\":\"" + d1 + "\",\"since\":100},{\"data\":\"" + d2 + "\",\"since\":150}]";
  nlohmann::json js = myCrestClient.getJson(str);
  myCrestClient.storeBatchPayloadsFiles(tagname, endtime, js);

Definition at line 2925 of file CrestApi.cxx.

                                                                                                          {
     const char* method_name = "CrestClient::storeBatchPayloads";
  
     if (m_mode == FILESYSTEM_MODE) {
       storeBatchPayloadsFs(tag_name, js);
       return;
     }
     if (!js.is_array()) {
       throw std::runtime_error("ERROR in " + std::string(method_name) + " JSON has wrong type (must be array)");
     }
  
     nlohmann::json jsObj = {};
     jsObj["datatype"] = "iovs";
     jsObj["format"] = "StoreSetDto";
     jsObj["size"] = js.size();
     jsObj["resources"] = js;
     std::string str = jsObj.dump();
     std::string retv = storeBatchPayloadFilesRequest(tag_name, endtime, str);
  
     nlohmann::json respond = getJson(retv, method_name);
   }

◆ storeBatchPayloadsFs() [1/2]

void Crest::CrestClient::storeBatchPayloadsFs	(	const std::string &	tag_name,
		nlohmann::json &	js
	)

inherited

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

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

Parameters

tag_name	- tag name.
iovsetupload	- iov data as a JSON object.

Example how to use these parameters:

  std::string name39 = "test_M";
  std::string str39 = "[{\"data\":\"aaa\",\"since\":100},{\"data\":\"bbb\",\"since\":150}]";
  nlohmann::json js39 = myCrestClient.getJson(str39);
  myCrestClient.storeBatchPayloadsFs(name39, js39);

Definition at line 1837 of file CrestApi.cxx.

                                                                                     {
     const char* method_name = "CrestClient::storeBatchPayloadsFs";
  
     try {
       for (auto& kvp : js) {
         std::string payload = kvp.value("data", "");
         int since = kvp.value("since", 0);
         storePayloadDump(tag_name, since, payload);
       }
     } // end of try
     catch (...) {
       throw std::runtime_error("ERROR in " + std::string(method_name) + " cannot store the data in a file");
     } // end of catch
     flush();
   }

◆ storeBatchPayloadsFs() [2/2]

void Crest::CrestClient::storeBatchPayloadsFs	(	const std::string &	tag_name,
		std::string &	iovsetupload
	)

inherited

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

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

Parameters

tag_name	- tag name.
iovsetupload	- iov data as a string.

Example how to use these parameters:

  std::string name39 = "test_M";
  std::string str39 = "[{\"data\":\"aaa\",\"since\":100},{\"data\":\"bbb\",\"since\":150}]";
  myCrestClient.storeBatchPayloadsFs(name39, str39);

Definition at line 1826 of file CrestApi.cxx.

                                                                                            {
     const char* method_name = "CrestClient::storeBatchPayloadsFs";
  
     nlohmann::json js = getJson(iovsetupload, method_name);
     if (!js.is_array()) {
       throw std::runtime_error("ERROR in CrestClient::storeBatchPayloadsFs: JSON has wrong type (must be array");
     }
  
     storeBatchPayloadsFs(tag_name, js);
   }

◆ storeData()

void Crest::CrestClient::storeData	(	const std::string &	tag,
		uint64_t	endtime,
		uint64_t	since,
		const std::string &	file
	)

inherited

This method stores a payload from a file in the database, associated to a given IOV since and tag name.

This method allows to insert a payload and an IOV.

Parameters

tag	- tag name.
since	- since. A parameter to create an IOV together with payload.
file	- the file name (with the path) which contains the payload.

Definition at line 3119 of file CrestApi.cxx.

                                                                                                           {
     const char* method_name = "CrestClient::storePayloadAsFile";
     checkFsException(method_name);
     std::string d = "file://" + file;
  
     std::string str = "[{\"data\":\"" + d + "\",\"since\":" +  std::to_string(since) + "}]";
     nlohmann::json js = getJson(str);
  
     storeBatchPayloadsFiles(tag, endtime, js); 
   }

◆ storeDataArray()

void Crest::CrestClient::storeDataArray	(	const std::string &	tag,
		uint64_t	endtime,
		std::map< uint64_t, std::string >	m
	)

inherited

This method stores several payloads from files in batch mode.

Parameters

tag_name	- tag name.
endtime	- end time.
m	- map with pairs: since - file name (with the path).

Example how to use these parameters:

  uint64_t endtime = 200;
  uint64_t since1 = 100;
  uint64_t since2 = 150;

  std::string file1 = "/tmp/mvg01.txt";
  std::string file2 = "/tmp/mvg02.txt";

  std::map<uint64_t, std::string> data;

  data[since1] = file1;
  data[since2] = file2;

  myCrestClient.storeBatchFiles(tagname, endtime, data);

Definition at line 3130 of file CrestApi.cxx.

                                                                                                        {
     nlohmann::json payload_data = nlohmann::json::array();
  
     std::map<uint64_t, std::string> :: iterator it;
     for(it=m.begin();it !=m.end();++it){
       std::string file_name = "file://" + it->second;
  
       nlohmann::json js_element =
       {
         {"since", it->first},
         {"data", file_name}
       };
  
       payload_data.push_back(js_element);
     }
  
     storeBatchPayloadsFiles(tag, endtime, payload_data);
   }

◆ storePayload()

void Crest::CrestClient::storePayload	(	const std::string &	tag,
		uint64_t	since,
		const std::string &	js
	)

inherited

Create a payload in the database, associated to a given iov since and tag name.

This method allows to insert a payload and an IOV. (This method is an analogue of the store_payload method in Python)

Parameters

tag	- tag name.
since	- since. A parameter to create an iov together with payload.
js	- payload.

Definition at line 1252 of file CrestApi.cxx.

                                                                                           {
     if (m_mode == FILESYSTEM_MODE) {
       storePayloadDump(tag, since, js);
       return;
     }
  
     nlohmann::json data = nlohmann::json::array();
     nlohmann::json itemD =
     {
       {"data", js},
       {"since", since}
     };
  
     data.push_back(itemD);
     storeBatchPayloads(tag, data);
   }

◆ storePayloadDump()

void Crest::CrestClient::storePayloadDump	(	const std::string &	tag,
		uint64_t	since,
		const std::string &	js
	)

inherited

Method to store a payload in the local file system.

This is an auxillary method. It is used by storePayload method if CrestClient is innitialized in the file storage mode. (The old name of this method is store_payload_dump)

Parameters

tag	- tag name.
since	- since.
js	- payload as a JSON object.

Definition at line 2446 of file CrestApi.cxx.

                                                                                               {
     std::ofstream myfile;
  
     // payload file:
     std::string hashCode = getHash(js);
     std::string workDir = m_data_folder;
     workDir += '/';
     workDir += getFirstLetters(hashCode);
     if (!std::filesystem::exists(std::filesystem::path(workDir))) {
       std::filesystem::create_directory(std::filesystem::path(workDir));
     }
     workDir += '/';
     workDir += hashCode;
     if (!std::filesystem::exists(std::filesystem::path(workDir))) {
       std::filesystem::create_directory(std::filesystem::path(workDir));
     }
  
     std::string tagFile = workDir + "/payload.json";
  
     myfile.open(tagFile);
     myfile << js;
     myfile.close();
  
     /*
        // meta info data example:
        {
         "hash": "9834876dcfb05cb167a5c24953eba58c4ac89b1adf57f28f2f9d09af107ee8f0",
         "insertionTime": "2020-12-08",
         "objectType": "JSON",
         "size": 3,
         "streamerInfo":
            "eyJmaWxlbmFtZSI6Ijk4MzQ4NzZkY2ZiMDVjYjE2N2E1YzI0OTUzZWJhNThjNGFjODliMWFkZjU3ZjI4ZjJmOWQwOWFmMTA3ZWU4ZjAiLCJmb3JtYXQiOiJKU09OIiwiaW5zZXJ0aW9uRGF0ZSI6IlR1ZSBEZWMgMDggMTE6MTg6NTAgR01UIDIwMjAifQ==",
         "version": "default"
        }
      */
  
     nlohmann::json jsn =
     {
       {"hash", hashCode},
       {"objectType", "JSON"},
       {"version", "default"},
       {"size", js.size()},
       {"streamerInfo", "none"},
       {"insertionTime", getDateAndTime()}
     };
  
  
     // payload meta info file:
     std::string metaFile = workDir + "/meta.json";
  
     myfile.open(metaFile);
     myfile << jsn.dump();
     myfile.close();
  
     // check if data exists
  
     if (m_data.find(tag) == m_data.end()) {
       try{
         nlohmann::json jsi = findAllIovsFs(tag);
         m_data.insert(std::pair<std::string, nlohmann::json>(tag, jsi));
       }
       catch (...) {
         try { // tag exists, but there are no IOVs
           nlohmann::json tagJS = findTag(tag);
           nlohmann::json jsFree = nlohmann::json::array({});
           m_data.insert(std::pair<std::string, nlohmann::json>(tag, jsFree));
         }
         catch (...) {
           throw std::runtime_error(
             "ERROR in CrestClient::storePayloadDump cannot get data for tag \"" + tag + "\" from file storage.");
         }
       }
     }
  
     std::map<std::string, nlohmann::json>::iterator it = m_data.find(tag);
     if (it != m_data.end()) {
       std::string link = hashCode;
       nlohmann::json iovs = it->second;
       nlohmann::json obj(nlohmann::json::value_t::object);
       obj["tagName"] = tag;
       obj["since"] = since;
       obj["insertionTime"] = 0;
       obj["payloadHash"] = link;
       iovs.push_back(obj);
       m_data[it->first] = iovs;
     }
   }

◆ streamTest()

void Crest::CrestClient::streamTest ( )

inherited

this is test only, later it will be deleted (The old method name is streamtest)

Definition at line 1810 of file CrestApi.cxx.

                                {
     std::string line;
  
     std::ifstream in("./test-03.txt");
     std::ofstream fout("./copy.txt");
     if (in.is_open() && fout.is_open()) {
       while (getline(in, line)) {
         fout << line << std::endl;
       }
     }
     in.close();
   }

◆ updateGlobalTag()

void Crest::CrestClient::updateGlobalTag	(	const std::string &	name,
		nlohmann::json	body
	)

inherited

This method allows to update a GlobalTag.Arguments: the name has to uniquely identify a global tag.

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

Parameters

name - global tag name

body

- JSON object. A new global tag in JSON format. Example for body parameter:

json body =
   {
      {"name","MvG_TEST_01"},
      {"validity",0},
      {"description","test"},
      {"release","1"},
      {"insertionTime","2018-12-18T11:32:58.081+0000"},
      {"snapshotTime","2018-12-18T11:32:57.952+0000"},
      {"scenario","test2"},
      {"workflow","M"},
      {"type","t"},
      {"snapshotTimeMilli","null"},
      {"insertionTimeMilli","null"}
   };

Definition at line 672 of file CrestApi.cxx.

                                                                             {
     const char* method_name = "CrestClient::updateGlobalTag";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_ADMIN_PATH;
     current_path += s_GLOBALTAG_PATH;
     current_path += '/';
     current_path += name;
  
     std::string retv;
  
     retv = performRequest(current_path, PUT, body, method_name);
   }

◆ updateTag()

void Crest::CrestClient::updateTag	(	const std::string &	tagname,
		nlohmann::json	body
	)

inherited

This method allows to update tag record in the CREST DB.

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

Parameters

tagname	- tg name.
body	- new parameters in the JSON format. This JSON object contain the parameters which have to be changed only. Example:

   json body =
   {
     {"description","none"},
     {"lastValidatedTime",0},
     {"endOfValidity",40}
   }

Definition at line 278 of file CrestApi.cxx.

                                                                          {
     const char* method_name = "CrestClient::updateTag";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
     current_path += '/';
     current_path += tagname;
  
     std::string retv;
  
     retv = performRequest(current_path, PUT, body, method_name);
   }

◆ updateTagMetaInfo() [1/2]

void Crest::CrestClient::updateTagMetaInfo	(	const std::string &	tagname,
		nlohmann::json &	js
	)

inherited

This method updates a tag meta info in the CREST database.

Parameters

tagname	- tag name
js	- a JSON object with new parameters (These parameters will be changed in the CREST DB). Example:

   nlohmann::json js =
   {
     {"tagName", "test_MvG4"},
     {"description", "desc-01"},
     {"tagInfo", "taginf-01"},
     {"chansize", 0},
     {"colsize", 0},
     {"insertionTime", "2019-03-14T13:29:25.286Z"}
   };

Definition at line 2085 of file CrestApi.cxx.

                                                                                 {
     const char* method_name = "CrestClient::updateTagMetaInfo";
  
     if (m_mode == FILESYSTEM_MODE) {
       std::string name = "";
       try{
         name = static_cast<std::string> (js["tagName"]);
       }
       catch (...) {
         throw std::runtime_error(
                 "ERROR in CrestClient::updateTagMetaInfo cannot get the tag name from tag meta info JSON.");
       }
  
       if (tagname != name) {
         throw std::runtime_error("ERROR in CrestClient::updateTagMetaInfo tagname in method and in JSON are different.");
       }
  
       updateTagMetaInfoFs(tagname, js);
       return;
     }
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
     current_path += '/';
     current_path += tagname;
     current_path += s_META_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, PUT, js, method_name);
   }

◆ updateTagMetaInfo() [2/2]

void Crest::CrestClient::updateTagMetaInfo ( nlohmann::json & js )

inherited

This method updates a tag meta info in the CREST database.

Parameters

js	- a JSON object with new parameters (These parameters will be changed in the CREST DB). Example:

   nlohmann::json js =
   {
     {"tagName", "test_MvG4"},
     {"description", "desc-01"},
     {"tagInfo", "taginf-01"},
     {"chansize", 0},
     {"colsize", 0},
     {"insertionTime", "2019-03-14T13:29:25.286Z"}
   };

Definition at line 2060 of file CrestApi.cxx.

                                                       {
     const char* method_name = "CrestClient::updateTagMetaInfo";
  
     std::string tagname = "";
     try{
       tagname = static_cast<std::string> (js["tagName"]);
     }
     catch (...) {
       throw std::runtime_error(
               "ERROR in CrestClient::updateTagMetaInfo cannot get the tag name from tag meta info JSON.");
     }
  
  
     if (m_mode == FILESYSTEM_MODE) {
       updateTagMetaInfoFs(tagname, js);
       return;
     }
  
     std::string current_path = m_PATH + s_TAG_PATH + '/' + tagname + s_META_PATH;
  
     std::string retv;
  
     retv = performRequest(current_path, PUT, js, method_name);
   }

◆ updateTagMetaInfoFs()

void Crest::CrestClient::updateTagMetaInfoFs	(	const std::string &	tagname,
		nlohmann::json &	js
	)

inherited

This auxillary method updates a tag meta info in local file storage.

Parameters

tagname	- tag name
js	- a JSON object with new parameters (These parameters will be changed in the CREST DB). Example:

   nlohmann::json js =
   {
     {"tagName", "test_MvG4"},
     {"description", "desc-01"},
     {"tagInfo", "taginf-01"},
     {"chansize", 0},
     {"colsize", 0},
     {"insertionTime", "2019-03-14T13:29:25.286Z"}
   };

Definition at line 2224 of file CrestApi.cxx.

                                                                                   {
     // Check if JSON contains the correct tag name:
     auto it = js.find("tagName");
  
     if (it != js.end()) {
       if (js["tagName"] != tagname) {
         throw std::runtime_error("ERROR in CrestClient::updateTagMetaInfoFs: JSON contains wrong tag name.");
       }
     }
  
     nlohmann::json jstmp;
     try{
       jstmp = getTagMetaInfoFs(tagname);
     }
     catch (const std::exception& e) {
       throw std::runtime_error(
               "ERROR in CrestClient::updateTagMetaInfoFs: the file storage does not contain the tag meta info for the tag " + tagname +
               " .");
     }
  
     // Write all keys/values from new JSON to old one:
     for (auto it = js.begin(); it != js.end(); it++) {
       jstmp[it.key()] = it.value();
     }
  
     try{
       createTagMetaInfoFs(jstmp);
     }
     catch (const std::exception& e) {
       throw std::runtime_error(
               "ERROR in CrestClient::updateTagMetaInfoFs: cannot write the tag meta info for the tag " + tagname +
               " on file storage.");
     }
  
     return;
   }

◆ updateTagSpecification()

void Crest::CrestClient::updateTagSpecification	(	const std::string &	tagname,
		const std::string &	objectType
	)

inherited

This method cahnges object type specification.

(The old name of this method is update_tag_specification)

Parameters

tagname	- tag name.
objectType	- new object type.

Definition at line 293 of file CrestApi.cxx.

                                                                                                 {
     const char* method_name = "CrestClient::updateTagSpecification";
  
     checkFsException(method_name);
  
     std::string current_path = m_PATH;
     current_path += s_TAG_PATH;
     current_path += '/';
     current_path += tagname;
  
     nlohmann::json body;
     body["objectType"] = objectType;
  
  
     std::string retv;
     retv = performRequest(current_path, PUT, body, method_name);
   }

Member Data Documentation

◆ m_CREST_PROXY

char* Crest::CrestClient::m_CREST_PROXY = NULL

privateinherited

Definition at line 75 of file CrestApi.h.

◆ m_CREST_PROXY_VAR

const char* Crest::CrestClient::m_CREST_PROXY_VAR = "SOCKS_PROXY"

privateinherited

Definition at line 76 of file CrestApi.h.

◆ m_currentTag

std::string Crest::CrestClient::m_currentTag {}

privateinherited

Definition at line 72 of file CrestApi.h.

◆ m_data

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

privateinherited

Definition at line 70 of file CrestApi.h.

◆ m_data_folder

std::string Crest::CrestClient::m_data_folder {}

privateinherited

Definition at line 69 of file CrestApi.h.

◆ m_host

std::string Crest::CrestClient::m_host {}

privateinherited

Definition at line 65 of file CrestApi.h.

◆ m_isRewrite

bool Crest::CrestClient::m_isRewrite {}

privateinherited

Definition at line 71 of file CrestApi.h.

◆ m_mode

int Crest::CrestClient::m_mode {}

privateinherited

Definition at line 67 of file CrestApi.h.

◆ m_PATH

std::string Crest::CrestClient::m_PATH = "/api-v4.0"

privateinherited

Definition at line 74 of file CrestApi.h.

◆ m_port

std::string Crest::CrestClient::m_port {}

privateinherited

Definition at line 66 of file CrestApi.h.

◆ m_root_folder

std::string Crest::CrestClient::m_root_folder {}

privateinherited

Definition at line 68 of file CrestApi.h.

◆ s_ADMIN_PATH

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

inlinestaticprivateinherited

Definition at line 78 of file CrestApi.h.

◆ s_CREST_CLIENT_CHECK

const bool Crest::CrestClient::s_CREST_CLIENT_CHECK = false

inlinestaticinherited

Definition at line 259 of file CrestApi.h.

◆ s_CREST_CLIENT_VERSION

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

inlinestaticprivateinherited

Definition at line 122 of file CrestApi.h.

◆ s_DATA_PATH

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

inlinestaticprivateinherited

Definition at line 88 of file CrestApi.h.

◆ s_FOLDER_PATH

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

inlinestaticprivateinherited

Definition at line 90 of file CrestApi.h.

◆ s_FS_DATA_PATH

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

inlinestaticprivateinherited

Definition at line 103 of file CrestApi.h.

◆ s_FS_GLOBALTAG_FILE

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

inlinestaticprivateinherited

Definition at line 112 of file CrestApi.h.

◆ s_FS_GLOBALTAG_PATH

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

inlinestaticprivateinherited

Definition at line 102 of file CrestApi.h.

◆ s_FS_IOV_FILE

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

inlinestaticprivateinherited

Definition at line 106 of file CrestApi.h.

◆ s_FS_MAP_FILE

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

inlinestaticprivateinherited

Definition at line 113 of file CrestApi.h.

◆ s_FS_META_FILE

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

inlinestaticprivateinherited

Definition at line 109 of file CrestApi.h.

◆ s_FS_PALOAD_FILE

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

inlinestaticprivateinherited

Definition at line 110 of file CrestApi.h.

◆ s_FS_PATH

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

inlinestaticprivateinherited

Definition at line 115 of file CrestApi.h.

◆ s_FS_PREFIX_LENGTH

const int Crest::CrestClient::s_FS_PREFIX_LENGTH = 3

inlinestaticprivateinherited

Definition at line 117 of file CrestApi.h.

◆ s_FS_TAG_FILE

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

inlinestaticprivateinherited

Definition at line 105 of file CrestApi.h.

◆ s_FS_TAG_PATH

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

inlinestaticprivateinherited

Definition at line 101 of file CrestApi.h.

◆ s_FS_TAGMETAINFO_FILE

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

inlinestaticprivateinherited

Definition at line 107 of file CrestApi.h.

◆ s_GLOBALTAG_MAP_PATH

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

inlinestaticprivateinherited

Definition at line 84 of file CrestApi.h.

◆ s_GLOBALTAG_PATH

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

inlinestaticprivateinherited

Definition at line 83 of file CrestApi.h.

◆ s_IOV_PATH

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

inlinestaticprivateinherited

Definition at line 79 of file CrestApi.h.

◆ s_IOV_SIZE_PATH

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

inlinestaticprivateinherited

Definition at line 81 of file CrestApi.h.

◆ s_META_PATH

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

inlinestaticprivateinherited

Definition at line 87 of file CrestApi.h.

◆ s_METHOD_GROUPS

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

inlinestaticprivateinherited

Definition at line 95 of file CrestApi.h.

◆ s_METHOD_IOVS

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

inlinestaticprivateinherited

Definition at line 94 of file CrestApi.h.

◆ s_METHOD_MONITOR

const std::string Crest::CrestClient::s_METHOD_MONITOR = "MONITOR"

inlinestaticprivateinherited

Definition at line 96 of file CrestApi.h.

◆ s_MGMT_INFO_PATH

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

inlinestaticprivateinherited

Definition at line 121 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 123 of file CrestApi.h.

◆ s_MGMT_PATH

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

inlinestaticprivateinherited

Definition at line 120 of file CrestApi.h.

◆ s_MONITORING_PAYLOAD_PATH

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

inlinestaticprivateinherited

Definition at line 86 of file CrestApi.h.

◆ s_PAYLOAD_PATH

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

inlinestaticprivateinherited

Definition at line 85 of file CrestApi.h.

◆ s_RUNINFO_LIST_PATH

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

inlinestaticprivateinherited

Definition at line 92 of file CrestApi.h.

◆ s_RUNINFO_PATH

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

inlinestaticprivateinherited

Definition at line 91 of file CrestApi.h.

◆ s_TAG_PATH

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

inlinestaticprivateinherited

Definition at line 77 of file CrestApi.h.

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

CrestApiExt.h

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ Action

◆ CrestMode

Constructor & Destructor Documentation

◆ CrestClientExt() [1/3]

◆ CrestClientExt() [2/3]

◆ CrestClientExt() [3/3]

Member Function Documentation

◆ BOOST_PARAMETER_MEMBER_FUNCTION() [1/3]

◆ BOOST_PARAMETER_MEMBER_FUNCTION() [2/3]

◆ BOOST_PARAMETER_MEMBER_FUNCTION() [3/3]

◆ checkCrestVersion()

◆ checkCrestVersion2()

◆ checkErrors()

◆ checkFsException()

◆ checkResult()

◆ convertTagMetaInfo2CREST()

◆ convertTagMetaInfo2IOVDbSvc()

◆ createFolder()

◆ createGlobalTag() [1/3]

◆ createGlobalTag() [2/3]

◆ createGlobalTag() [3/3]

◆ createGlobalTagFs()

◆ createGlobalTagMap() [1/2]

◆ createGlobalTagMap() [2/2]

◆ createGlobalTagMapFs()

◆ createIov()

◆ createPayload()

◆ createRunLumiInfo()

◆ createTag() [1/3]

◆ createTag() [2/3]

◆ createTag() [3/3]

◆ createTagDump()

◆ createTagMetaInfo() [1/2]

◆ createTagMetaInfo() [2/2]

◆ createTagMetaInfoFs()

◆ createTagMetaInfoIOVDbSvc() [1/2]

◆ createTagMetaInfoIOVDbSvc() [2/2]

◆ findAllIovs() [1/2]

◆ findAllIovs() [2/2]

◆ findAllIovsFs() [1/2]

◆ findAllIovsFs() [2/2]

◆ findGlobalTag()

◆ findGlobalTagAsString()

◆ findGlobalTagFs()

◆ findGlobalTagMap()

◆ findGlobalTagMapFs()

◆ findRunLumiInfo()

◆ findTag()

◆ findTagFs()

◆ flush()

◆ getBlob()

◆ getBlobFs()

◆ getBlobInStream()

◆ getBlobInStreamFs()

◆ getClientVersion()

◆ getCrestVersion()

◆ getCrestVersion2()

◆ getDataPath()

◆ getDateAndTime()

◆ getEnvA()

◆ getFileList()

◆ getFileName()

◆ getFileString()

◆ getFirstLetters()

◆ getHash()

◆ getJson() [1/2]

◆ getJson() [2/2]

◆ getMajorVersion()

◆ getMgmtInfo()

◆ getMgmtInfo2()

◆ getPayloadAsJson()

◆ getPayloadAsJsonFS()