Namespaces
	auth

	impl

	payloadInspector

	persistency

	RelationalAuthenticationService

	serialization

	service

	time

	XMLAuthenticationService

Classes
struct	AuthorizationData

class	BaseKeyed

class	BasicPayload

class	Binary

class	BTransitionAnalyzer

class	CoralServiceFactory

class	CoralServiceManager

struct	CoralServiceWrapper

struct	CoralServiceWrapperBase

struct	CredentialData

class	CredentialStore

class	CSScopedSession

class	DataProxyWrapperBase

struct	DefaultInitializer

class	EmptyIOVSource

class	FileBasedEmptySource

class	FileReader

class	GenericSummary

class	GTEntry_t

struct	GTMetadata_t

struct	Iov_t

class	IOVDescription

class	IOVKeysDescription

class	IOVProvenance

class	IOVUserMetaData

class	KeyedElement

struct	LessFrame

struct	LogDBEntry_t

class	OMSService

class	OMSServiceQuery

class	OMSServiceResult

class	OMSServiceResultIterator

class	OMSServiceResultRef

struct	PrincipalData

struct	RealTimeType

struct	RealTimeType< hash >

struct	RealTimeType< lumiid >

struct	RealTimeType< runnumber >

struct	RealTimeType< timestamp >

struct	RealTimeType< userid >

struct	RunInfo_t

class	SmallWORMDict

class	StreamerInfo

class	Summary

struct	Tag_t

struct	TagInfo_t

struct	TagMetadata_t

struct	TimeTypeSpecs

struct	TimeTypeTraits

class	UnregisteredRecordException

struct	UserLogInfo

class	Utilities

class	UtilitiesError

Typedefs
typedef cond::serialization::InputArchive	CondInputArchive

typedef cond::serialization::OutputArchive	CondOutputArchive

typedef edmplugin::PluginFactory< cond::CoralServiceWrapperBase *()>	CoralServicePluginFactory

typedef persistency::Exception	Exception

typedef std::string	Hash

typedef edmplugin::PluginFactory< cond::DataProxyWrapperBase *()>	ProxyFactory

typedef unsigned long long	Time_t

typedef unsigned long long	uint64_t

typedef std::pair< unsigned int, unsigned int >	UnpackedTime

typedef std::pair< Time_t, Time_t >	ValidityInterval

Enumerations
enum	SynchronizationType { SYNCH_ANY = 0, SYNCH_VALIDATION, SYNCH_OFFLINE, SYNCH_MC, SYNCH_RUNMC, SYNCH_HLT, SYNCH_EXPRESS, SYNCH_PROMPT, SYNCH_PCL }

enum	TimeType { invalid = -1, runnumber = 0, timestamp, lumiid, hash, userid }

Functions
std::string	boost_version_label ()

template<typename T >
T *	createPayload (const std::string &payloadTypeName)

template<>
HcalCalibrationQIEData *	createPayload< HcalCalibrationQIEData > (const std::string &payloadTypeName)

template<>
std::string *	createPayload< std::string > (const std::string &payloadTypeName)

template<typename T >
std::unique_ptr< T >	default_deserialize (const std::string &payloadType, const Binary &payloadData, const Binary &streamerInfoData)

template<typename T >
std::unique_ptr< T >	deserialize (const std::string &payloadType, const Binary &payloadData, const Binary &streamerInfoData)

template<>
std::unique_ptr< BaseKeyed >	deserialize< BaseKeyed > (const std::string &payloadType, const Binary &payloadData, const Binary &streamerInfoData)

template<>
std::unique_ptr< condex::Efficiency >	deserialize< condex::Efficiency > (const std::string &payloadType, const Binary &payloadData, const Binary &streamerInfoData)

template<>
std::unique_ptr< CSCReadoutMapping >	deserialize< CSCReadoutMapping > (const std::string &payloadType, const Binary &payloadData, const Binary &streamerInfoData)

template<>
std::unique_ptr< CSCReadoutMappingForSliceTest >	deserialize< CSCReadoutMappingForSliceTest > (const std::string &payloadType, const Binary &payloadData, const Binary &streamerInfoData)

template<>
std::unique_ptr< PerformancePayload >	deserialize< PerformancePayload > (const std::string &payloadType, const Binary &payloadData, const Binary &streamerInfoData)

LHCInfo::FillType	fillTypeFromString (const std::string &s_fill_type)

const TimeTypeSpecs &	findSpecs (std::string const &name)

size_t	getAuthorizationEntries (const std::string &schemaVersion, coral::ISchema &schema, int principalId, const std::string &role, const std::string &connectionString)

static size_t	getBodyCallback (void contents, size_t size, size_t nmemb, void ptr)

int	getch ()

std::tuple< std::string, std::string, std::string >	getDbCredentials (const std::string &connectionString, int accessType, const std::string &authPath)

cond::Time_t	getLastLumiFromOMS (const std::string &omsServiceUrl)

cond::Time_t	getLatestLumiFromFile (const std::string &fileName)

std::string	getLoginName ()

bool	getNextSequenceValue (const std::string &schemaVersion, coral::ISchema &schema, const std::string &sequenceName, int &value)

std::string	getpass (const std::string &prompt, bool show_asterisk=true)

std::string	getpassForUser (const std::string &userName)

unsigned long long	hash64 (unsigned char *k, unsigned long long length, unsigned long long level)

unsigned long	httpGet (const std::string &urlString, std::string &info)

const Time_t	invalidTime (0)

Iov_t	makeIov (cond::Time_t since, const Hash &payloadId)

void	parseLineForNamedParams (const std::string &line, std::map< std::string, std::string > &params)

LHCInfo::ParticleType	particleTypeFromString (const std::string &s_particle_type)

const char *	pluginCategory ()

char	randomChar ()

std::string	schemaLabel (const std::string &serviceName, const std::string &userName)

std::string	schemaLabelForCredentialStore (const std::string &connectionString)

bool	selectAuthorization (const std::string &schemaVersion, coral::ISchema &schema, int principalId, const std::string &role, const std::string &connectionString, AuthorizationData &destination)

bool	selectConnection (const std::string &schemaVersion, coral::ISchema &schema, const std::string &connectionLabel, CredentialData &destination)

bool	selectPrincipal (const std::string &schemaVersion, coral::ISchema &schema, const std::string &principal, PrincipalData &destination)

template<typename T >
std::pair< Binary, Binary >	serialize (const T &payload)

bool	setPermissionData (const std::string &schemaVersion, coral::ISchema &schema, int principalId, const std::string &principalKey, const std::string &role, const std::string &connectionString, int connectionId, const std::string &connectionKey, std::stringstream &log)

SynchronizationType	synchronizationTypeFromName (const std::string &name)

std::string	synchronizationTypeNames (SynchronizationType type)

void	throwException (const std::string &message, const std::string &methodName)

const Time_t	TIMELIMIT (std::numeric_limits< Time_t >::max())

std::string const &	timeTypeNames (int)

std::pair< int, std::string >	updateConnectionData (const std::string &schemaVersion, coral::ISchema &schema, const std::string &adminKey, const std::string &connectionLabel, const std::string &userName, const std::string &password, bool forceUpdate, std::stringstream &log)

std::pair< int, std::string >	updatePrincipalData (const std::string &schemaVersion, coral::ISchema &schema, const std::string &authenticationKey, const std::string &principalName, const std::string &adminKey, bool init, std::stringstream &log)

Variables
static constexpr unsigned int	HASH_SIZE = 40

static const std::pair< const char *, LHCInfo::FillType >	s_fillTypeMap []

static std::pair< const char *, SynchronizationType >	s_obsoleteSynchronizationTypeArray []

static const std::pair< const char *, LHCInfo::ParticleType >	s_particleTypeMap []

static std::pair< const char *, SynchronizationType >	s_synchronizationTypeArray []

const unsigned int	TIMETYPE_LIST_MAX = 5

const cond::TimeType	timeTypeList [TIMETYPE_LIST_MAX] = {runnumber, timestamp, lumiid, hash, userid}

const TimeTypeSpecs	timeTypeSpecs []

const cond::TimeType	timeTypeValues [] = {runnumber, timestamp, lumiid, hash, userid}

Detailed Description

The wrapper is used to allow edm::PluginFactory to change its return type to unique_ptr from a raw pointer. The unique_ptr does not work for coral::Service, because its destructor is protected and ownership is managed by intrusive reference counting.

Serialization.h CondCore/CondDB/interface/Serialization.h Description: functions for serializing the payload objects.

Typedef Documentation

◆ CondInputArchive

typedef cond::serialization::InputArchive cond::CondInputArchive

Definition at line 61 of file Serialization.h.

◆ CondOutputArchive

typedef cond::serialization::OutputArchive cond::CondOutputArchive

Definition at line 62 of file Serialization.h.

◆ CoralServicePluginFactory

typedef edmplugin::PluginFactory<cond::CoralServiceWrapperBase*()> cond::CoralServicePluginFactory

Definition at line 25 of file CoralServiceFactory.h.

◆ Exception

typedef persistency::Exception cond::Exception

Definition at line 25 of file Exception.h.

◆ Hash

typedef std::string cond::Hash

Definition at line 43 of file Types.h.

◆ ProxyFactory

typedef edmplugin::PluginFactory<cond::DataProxyWrapperBase*()> cond::ProxyFactory

Definition at line 29 of file ProxyFactory.h.

◆ Time_t

typedef unsigned long long cond::Time_t

Definition at line 14 of file Time.h.

◆ uint64_t

typedef unsigned long long cond::uint64_t

Definition at line 13 of file Time.h.

◆ UnpackedTime

typedef std::pair<unsigned int, unsigned int> cond::UnpackedTime

Definition at line 15 of file Time.h.

◆ ValidityInterval

typedef std::pair<Time_t, Time_t> cond::ValidityInterval

Definition at line 17 of file Time.h.

Enumeration Type Documentation

◆ SynchronizationType

enum cond::SynchronizationType

Enumerator
SYNCH_ANY
SYNCH_VALIDATION
SYNCH_OFFLINE
SYNCH_MC
SYNCH_RUNMC
SYNCH_HLT
SYNCH_EXPRESS
SYNCH_PROMPT
SYNCH_PCL

Definition at line 27 of file Types.h.

                {
     SYNCH_ANY = 0,
     SYNCH_VALIDATION,
     SYNCH_OFFLINE,
     SYNCH_MC,
     SYNCH_RUNMC,
     SYNCH_HLT,
     SYNCH_EXPRESS,
     SYNCH_PROMPT,
     SYNCH_PCL
   } SynchronizationType;

◆ TimeType

enum cond::TimeType

Enumerator
invalid
runnumber
timestamp
lumiid
hash
userid

Definition at line 19 of file Time.h.

19 { invalid = -1, runnumber = 0, timestamp, lumiid, hash, userid } TimeType;

cond::userid

Definition: Time.h:19

cond::runnumber

Definition: Time.h:19

align::invalid

Definition: StructureType.h:18

cond::hash

Definition: Time.h:19

cond::lumiid

Definition: Time.h:19

cond::timestamp

Definition: Time.h:19

cond::time::TimeType

cond::TimeType TimeType

Definition: Time.h:30

Function Documentation

◆ boost_version_label()

std::string cond::boost_version_label ( )

inline

Definition at line 24 of file Payload2XMLModule.h.

References contentValuesCheck::ss.

Referenced by PYBIND11_MODULE().

                                          {
     std::stringstream ss;
     ss << BOOST_VERSION / 100000 << ".";
     ss << BOOST_VERSION / 100 % 1000 << ".";
     ss << BOOST_VERSION % 100;
     return ss.str();
   }

◆ createPayload()

template<typename T >

T* cond::createPayload ( const std::string & payloadTypeName )

Definition at line 31 of file Serialization.h.

References AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                      {
     std::string userTypeName = demangledName(typeid(T));
     if (userTypeName != payloadTypeName)
       throwException(
           std::string("Type mismatch, user type: \"" + userTypeName + "\", target type: \"") + payloadTypeName + "\"",
           "createPayload");
     return new T;
   }

◆ createPayload< HcalCalibrationQIEData >()

template<>

HcalCalibrationQIEData* cond::createPayload< HcalCalibrationQIEData > ( const std::string & payloadTypeName )

Definition at line 37 of file plugin.cc.

References AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                                                                   {
     if (payloadTypeName == "HcalCalibrationQIEData")
       return new HcalCalibrationQIEData(nullptr);
     throwException(std::string("Type mismatch, target object is type \"") + payloadTypeName + "\"", "createPayload");
   }

◆ createPayload< std::string >()

template<>

std::string* cond::createPayload< std::string > ( const std::string & payloadTypeName )

inline

Definition at line 41 of file Serialization.h.

References AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                                                {
     std::string userTypeName = demangledName(typeid(std::string));
     if (payloadTypeName != userTypeName && payloadTypeName != "std::string")
       throwException(std::string("Type mismatch, user type: \"std::string\", target type: \"") + payloadTypeName + "\"",
                      "createPayload");
     return new std::string;
   }

◆ default_deserialize()

template<typename T >

std::unique_ptr<T> cond::default_deserialize	(	const std::string &	payloadType,
		const Binary &	payloadData,
		const Binary &	streamerInfoData
	)

Definition at line 86 of file Serialization.h.

References cond::Binary::data(), MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, jetsAK4_Puppi_cff::payload, HLT_2022v15_cff::payloadType, cond::Binary::size(), AlCaHLTBitMon_QueryRunRegistry::string, cond::StreamerInfo::techVersion(), and throwException().

                                                                          {
     std::unique_ptr<T> payload;
     std::stringbuf sstreamerInfoBuf;
     sstreamerInfoBuf.pubsetbuf(static_cast<char*>(const_cast<void*>(streamerInfoData.data())), streamerInfoData.size());
     std::string streamerInfo = sstreamerInfoBuf.str();
     try {
       std::stringbuf sdataBuf;
       sdataBuf.pubsetbuf(static_cast<char*>(const_cast<void*>(payloadData.data())), payloadData.size());
       std::istream dataBuffer(&sdataBuf);
       CondInputArchive ia(dataBuffer);
       payload.reset(createPayload<T>(payloadType));
       ia >> (*payload);
     } catch (const std::exception& e) {
       std::string errorMsg("De-serialization failed: ");
       std::string em(e.what());
       if (em == "unsupported version") {
         errorMsg += "the current boost version (" + StreamerInfo::techVersion() +
                     ") is unable to read the payload. Data might have been serialized with an incompatible version.";
       } else if (em == "input stream error") {
         errorMsg += "data size does not fit with the current class layout. The Class " + payloadType +
                     " might have been changed with respect to the layout used in the upload.";
       } else {
         errorMsg += em;
       }
       if (!streamerInfo.empty())
         errorMsg += " Payload serialization info: " + streamerInfo;
       throwException(errorMsg, "default_deserialize");
     }
     return payload;
   }

◆ deserialize()

template<typename T >

std::unique_ptr<T> cond::deserialize	(	const std::string &	payloadType,
		const Binary &	payloadData,
		const Binary &	streamerInfoData
	)

Definition at line 121 of file Serialization.h.

References HLT_2022v15_cff::payloadType.

                                                                  {
     return default_deserialize<T>(payloadType, payloadData, streamerInfoData);
   }

◆ deserialize< BaseKeyed >()

template<>

std::unique_ptr< BaseKeyed > cond::deserialize< BaseKeyed >	(	const std::string &	payloadType,
		const Binary &	payloadData,
		const Binary &	streamerInfoData
	)

Definition at line 39 of file plugin.cc.

References DESERIALIZE_BASE_CASE, DESERIALIZE_POLIMORPHIC_CASE, HLT_2022v15_cff::payloadType, AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                                                     {
     DESERIALIZE_BASE_CASE(BaseKeyed);
     DESERIALIZE_POLIMORPHIC_CASE(BaseKeyed, condex::ConfI);
     DESERIALIZE_POLIMORPHIC_CASE(BaseKeyed, condex::ConfI);
 
     // here we come if none of the deserializations above match the payload type:
     throwException(std::string("Type mismatch, target object is type \"") + payloadType + "\"", "deserialize<>");
   }

◆ deserialize< condex::Efficiency >()

template<>

std::unique_ptr<condex::Efficiency> cond::deserialize< condex::Efficiency >	(	const std::string &	payloadType,
		const Binary &	payloadData,
		const Binary &	streamerInfoData
	)

Definition at line 25 of file plugin.cc.

References DESERIALIZE_POLIMORPHIC_CASE, HLT_2022v15_cff::payloadType, AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                                                                       {
     // DESERIALIZE_BASE_CASE( condex::Efficiency ); abstract
     DESERIALIZE_POLIMORPHIC_CASE(condex::Efficiency, condex::ParametricEfficiencyInPt);
     DESERIALIZE_POLIMORPHIC_CASE(condex::Efficiency, condex::ParametricEfficiencyInEta);
 
     // here we come if none of the deserializations above match the payload type:
     throwException(std::string("Type mismatch, target object is type \"") + payloadType + "\"", "deserialize<>");
   }

◆ deserialize< CSCReadoutMapping >()

template<>

std::unique_ptr<CSCReadoutMapping> cond::deserialize< CSCReadoutMapping >	(	const std::string &	payloadType,
		const Binary &	payloadData,
		const Binary &	streamerInfoData
	)

Definition at line 65 of file plugin.cc.

References DESERIALIZE_POLIMORPHIC_CASE, HLT_2022v15_cff::payloadType, AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                                                                     {
     // DESERIALIZE_BASE_CASE( CSCReadoutMapping ); abstract
     DESERIALIZE_POLIMORPHIC_CASE(CSCReadoutMapping, CSCReadoutMappingFromFile);
     // here we come if none of the deserializations above match the payload type:
     throwException(std::string("Type mismatch, target object is type \"") + payloadType + "\"", "deserialize<>");
   }

◆ deserialize< CSCReadoutMappingForSliceTest >()

template<>

std::unique_ptr<CSCReadoutMappingForSliceTest> cond::deserialize< CSCReadoutMappingForSliceTest >	(	const std::string &	payloadType,
		const Binary &	payloadData,
		const Binary &	streamerInfoData
	)

Definition at line 74 of file plugin.cc.

References DESERIALIZE_POLIMORPHIC_CASE, HLT_2022v15_cff::payloadType, AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                                                                {
     // DESERIALIZE_BASE_CASE( CSCReadoutMappingForSliceTest ); abstract
     DESERIALIZE_POLIMORPHIC_CASE(CSCReadoutMappingForSliceTest, CSCReadoutMappingFromFile);
     // here we come if none of the deserializations above match the payload type:
     throwException(std::string("Type mismatch, target object is type \"") + payloadType + "\"", "deserialize<>");
   }

◆ deserialize< PerformancePayload >()

template<>

std::unique_ptr<PerformancePayload> cond::deserialize< PerformancePayload >	(	const std::string &	payloadType,
		const Binary &	payloadData,
		const Binary &	streamerInfoData
	)

Definition at line 18 of file PerformanceRecordPlugin.cc.

References DESERIALIZE_POLIMORPHIC_CASE, HLT_2022v15_cff::payloadType, AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

                                                                                                       {
     // DESERIALIZE_BASE_CASE( PerformancePayload );  abstract
     DESERIALIZE_POLIMORPHIC_CASE(PerformancePayload, PerformancePayloadFromTFormula);
     DESERIALIZE_POLIMORPHIC_CASE(PerformancePayload, PerformancePayloadFromBinnedTFormula);
     DESERIALIZE_POLIMORPHIC_CASE(PerformancePayload, PerformancePayloadFromTable);
     // here we come if none of the deserializations above match the payload type:
     throwException(std::string("Type mismatch, target object is type \"") + payloadType + "\"", "createPayload");
   }

◆ fillTypeFromString()

LHCInfo::FillType cond::fillTypeFromString ( const std::string & s_fill_type )

Definition at line 35 of file LHCInfoPopConSourceHandler.cc.

References mps_fire::i, s_fillTypeMap, and LHCInfo::UNKNOWN.

                                                                    {
     for (auto const& i : s_fillTypeMap)
       if (s_fill_type == i.first)
         return i.second;
     return LHCInfo::UNKNOWN;
   }

◆ findSpecs()

const TimeTypeSpecs & cond::findSpecs ( std::string const & name )

Definition at line 23 of file Time.cc.

References Exception, mps_fire::i, Skims_PA_cff::name, TIMETYPE_LIST_MAX, and timeTypeSpecs.

Referenced by cond::time::timeTypeFromName().

                                                         {
     size_t i = 0;
     for (; i < TIMETYPE_LIST_MAX; i++)
       if (name == timeTypeSpecs[i].name)
         return timeTypeSpecs[i];
     throw cms::Exception("invalid timetype: " + name);
     return timeTypeSpecs[0];  // compiler happy
   }

◆ getAuthorizationEntries()

size_t cond::getAuthorizationEntries	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		int	principalId,
		const std::string &	role,
		const std::string &	connectionString
	)

Definition at line 322 of file CredentialStore.cc.

References AUTH_ID_COL(), AUTHORIZATION_TABLE(), l1RCTOmdsFedVectorProducer_cfi::connectionString, P_ID_COL(), contentValuesFiles::query, ROLE_COL(), SCHEMA_COL(), AlCaHLTBitMon_QueryRunRegistry::string, and tname().

Referenced by cond::CredentialStore::unsetPermission().

                                                                     {
     std::unique_ptr<coral::IQuery> query(schema.tableHandle(tname(AUTHORIZATION_TABLE, schemaVersion)).newQuery());
     coral::AttributeList readBuff;
     readBuff.extend<int>(AUTH_ID_COL);
     coral::AttributeList whereData;
     whereData.extend<std::string>(SCHEMA_COL);
     std::stringstream whereClause;
     whereClause << SCHEMA_COL << " = :" << SCHEMA_COL;
     if (principalId >= 0) {
       whereData.extend<int>(P_ID_COL);
       whereClause << "AND" << P_ID_COL << " = :" << P_ID_COL;
     }
     if (!role.empty()) {
       whereData.extend<std::string>(ROLE_COL);
       whereClause << " AND " << ROLE_COL << " = :" << ROLE_COL;
     }
     whereData[SCHEMA_COL].data<std::string>() = connectionString;
     if (principalId >= 0)
       whereData[P_ID_COL].data<int>() = principalId;
     if (!role.empty())
       whereData[ROLE_COL].data<std::string>() = role;
     query->defineOutput(readBuff);
     query->addToOutputList(AUTH_ID_COL);
     query->setCondition(whereClause.str(), whereData);
     coral::ICursor& cursor = query->execute();
     size_t n_entries = 0;
     while (cursor.next()) {
       n_entries += 1;
     }
     return n_entries;
   }

◆ getBodyCallback()

static size_t cond::getBodyCallback	(	void *	contents,
		size_t	size,
		size_t	nmemb,
		void *	ptr
	)

static

Definition at line 10 of file WebUtils.cc.

References relmon_rootfiles_spy::contents, findQualityFiles::size, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by httpGet().

                                                                                       {
     // Cast ptr to std::string pointer and append contents to that string
     ((std::string*)ptr)->append((char*)contents, size * nmemb);
     return size * nmemb;
   }

◆ getch()

int cond::getch ( )

Definition at line 19 of file Utilities.cc.

Referenced by getpass().

               {
     int ch;
     struct termios t_old, t_new;
 
     tcgetattr(STDIN_FILENO, &t_old);
     t_new = t_old;
     t_new.c_lflag &= ~(ICANON | ECHO);
     tcsetattr(STDIN_FILENO, TCSANOW, &t_new);
 
     ch = getchar();
 
     tcsetattr(STDIN_FILENO, TCSANOW, &t_old);
     return ch;
   }

◆ getDbCredentials()

std::tuple<std::string, std::string, std::string> cond::getDbCredentials	(	const std::string &	connectionString,
		int	accessType,
		const std::string &	authPath
	)

Definition at line 8 of file CondDBPyBind11Wrappers.cc.

References lumi_dqm_sourceclient-live_cfg::authPath, cond::auth::COND_AUTH_PATH, l1RCTOmdsFedVectorProducer_cfi::connectionString, dqmdumpme::first, cond::CredentialStore::getUserCredentials(), cond::CredentialStore::keyPrincipalName(), runTheMatrix::ret, cond::auth::s_roleCodeArray, cond::CredentialStore::setUpForConnectionString(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PYBIND11_MODULE().

                                                                                                 {
     std::string ap = authPath;
     if (ap.empty()) {
       ap = std::string(std::getenv(cond::auth::COND_AUTH_PATH));
     }
     auto ret = std::make_tuple(std::string(""), std::string(""), std::string(""));
     if (!ap.empty()) {
       CredentialStore credDb;
       credDb.setUpForConnectionString(connectionString, ap);
       std::string role(cond::auth::s_roleCodeArray[accessType].first);
       auto creds = credDb.getUserCredentials(connectionString, role);
       ret = std::tie(credDb.keyPrincipalName(), creds.first, creds.second);
     }
     return ret;
   }

◆ getLastLumiFromOMS()

cond::Time_t cond::getLastLumiFromOMS ( const std::string & omsServiceUrl )

Definition at line 58 of file OnlineDBOutputService.cc.

References getInfoFromService(), info(), cond::time::lumiTime(), cond::time::MIN_VAL(), beam_dqm_sourceclient-live_cfg::omsServiceUrl, writedatasetfile::run, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cond::service::OnlineDBOutputService::getLastLumiProcessed().

                                                                 {
     cond::Time_t lastLumiProcessed = cond::time::MIN_VAL;
     std::string info("");
     if (!getInfoFromService(omsServiceUrl, info))
       throw Exception("Can't get data from OMS Service.");
     std::istringstream sinfo(info);
     std::string srun;
     if (!std::getline(sinfo, srun, ',')) {
       throw Exception("Can't get run runmber info from OMS Service.");
     }
     std::string slumi;
     if (!std::getline(sinfo, slumi, ',')) {
       throw Exception("Can't get lumi id from OMS Service.");
     }
     unsigned int run = std::stoul(srun);
     unsigned int lumi = std::stoul(slumi);
     lastLumiProcessed = cond::time::lumiTime(run, lumi);
     return lastLumiProcessed;
   }

◆ getLatestLumiFromFile()

cond::Time_t cond::getLatestLumiFromFile ( const std::string & fileName )

Definition at line 47 of file OnlineDBOutputService.cc.

References MillePedeFileConverter_cfg::fileName, beam_dqm_sourceclient-live_cfg::lastLumiFile, cond::time::MIN_VAL(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cond::service::OnlineDBOutputService::getLastLumiProcessed().

                                                               {
     cond::Time_t lastLumiProcessed = cond::time::MIN_VAL;
     std::ifstream lastLumiFile(fileName);
     if (lastLumiFile) {
       lastLumiFile >> lastLumiProcessed;
     } else {
       throw Exception(std::string("Can't access lastLumi file ") + fileName);
     }
     return lastLumiProcessed;
   }

◆ getLoginName()

std::string cond::getLoginName ( )

Definition at line 42 of file DecodingKey.cc.

References mps_check::msg, AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

Referenced by cond::auth::DecodingKey::init().

                            {
     std::string loginName("");
     struct passwd* userp = ::getpwuid(::getuid());
     if (userp) {
       char* uName = userp->pw_name;
       if (uName) {
         loginName += uName;
       }
     }
     if (loginName.empty()) {
       std::string msg("Cannot determine login name.");
       throwException(msg, "DecodingKey::getLoginName");
     }
     return loginName;
   }

◆ getNextSequenceValue()

bool cond::getNextSequenceValue	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		const std::string &	sequenceName,
		int &	value
	)

Definition at line 358 of file CredentialStore.cc.

References contentValuesFiles::query, runTheMatrix::ret, SEQUENCE_NAME_COL(), SEQUENCE_TABLE(), SEQUENCE_VALUE_COL(), TrackCollections2monitor_cff::sequenceName, AlCaHLTBitMon_QueryRunRegistry::string, and tname().

Referenced by setPermissionData(), updateConnectionData(), and updatePrincipalData().

                                         {
     bool ret = false;
     std::unique_ptr<coral::IQuery> query(schema.tableHandle(tname(SEQUENCE_TABLE, schemaVersion)).newQuery());
     query->limitReturnedRows(1, 0);
     query->addToOutputList(SEQUENCE_VALUE_COL);
     query->defineOutputType(SEQUENCE_VALUE_COL, coral::AttributeSpecification::typeNameForType<int>());
     query->setForUpdate();
     std::string whereClause(SEQUENCE_NAME_COL + " = :" + SEQUENCE_NAME_COL);
     coral::AttributeList rowData;
     rowData.extend<std::string>(SEQUENCE_NAME_COL);
     rowData.begin()->data<std::string>() = sequenceName;
     query->setCondition(whereClause, rowData);
     coral::ICursor& cursor = query->execute();
     if (cursor.next()) {
       value = cursor.currentRow().begin()->data<int>() + 1;
       ret = true;
     } else {
       return false;
     }
     // update...
     coral::AttributeList updateData;
     updateData.extend<std::string>(SEQUENCE_NAME_COL);
     updateData.extend<int>(SEQUENCE_VALUE_COL);
     std::string setClause(SEQUENCE_VALUE_COL + " = :" + SEQUENCE_VALUE_COL);
     std::string whClause(SEQUENCE_NAME_COL + " = :" + SEQUENCE_NAME_COL);
     coral::AttributeList::iterator iAttribute = updateData.begin();
     iAttribute->data<std::string>() = sequenceName;
     ++iAttribute;
     iAttribute->data<int>() = value;
     schema.tableHandle(tname(SEQUENCE_TABLE, schemaVersion)).dataEditor().updateRows(setClause, whClause, updateData);
     return ret;
   }

◆ getpass()

std::string cond::getpass	(	const std::string &	prompt,
		bool	show_asterisk = `true`
	)

Definition at line 34 of file Utilities.cc.

References gather_cfg::cout, getch(), EcalCondDBWriter_cfi::password, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getpassForUser().

                                                                  {
     const char BACKSPACE = 127;
     const char RETURN = 10;
 
     std::string password;
     unsigned char ch = 0;
 
     std::cout << prompt;
 
     while ((ch = getch()) != RETURN) {
       if (ch == BACKSPACE) {
         if (password.length() != 0) {
           if (show_asterisk)
             std::cout << "\b \b";
           password.resize(password.length() - 1);
         }
       } else {
         password += ch;
         if (show_asterisk)
           std::cout << '*';
       }
     }
     std::cout << std::endl;
     return password;
   }

◆ getpassForUser()

std::string cond::getpassForUser ( const std::string & userName )

Definition at line 60 of file Utilities.cc.

References getpass(), AlCaHLTBitMon_QueryRunRegistry::string, and EcalCondDBWriter_cfi::userName.

                                                       {
     std::string prompt("Enter password for user ");
     prompt += userName;
     prompt += ": ";
     return getpass(prompt, true);
   }

◆ hash64()

ub8 cond::hash64	(	unsigned char *	k,
		unsigned long long	length,
		unsigned long long	level
	)

Definition at line 68 of file hash64.cc.

References a, b, HltBtagPostValidation_cff::c, dqmdumpme::k, personalPlayback::level, L1DTConfigBti_cff::LL, and mix64.

Referenced by cond::KeyedElement::convert().

   {
     ub8 a, b, c, len;
 
     /* Set up the internal state */
     len = length;
     a = b = level;            /* the previous hash value */
     c = 0x9e3779b97f4a7c13LL; /* the golden ratio; an arbitrary value */
 
     /*---------------------------------------- handle most of the key */
     if (((unsigned long)k) & 7) {
       while (len >= 24) {
         a += (k[0] + ((ub8)k[1] << 8) + ((ub8)k[2] << 16) + ((ub8)k[3] << 24) + ((ub8)k[4] << 32) + ((ub8)k[5] << 40) +
               ((ub8)k[6] << 48) + ((ub8)k[7] << 56));
         b += (k[8] + ((ub8)k[9] << 8) + ((ub8)k[10] << 16) + ((ub8)k[11] << 24) + ((ub8)k[12] << 32) +
               ((ub8)k[13] << 40) + ((ub8)k[14] << 48) + ((ub8)k[15] << 56));
         c += (k[16] + ((ub8)k[17] << 8) + ((ub8)k[18] << 16) + ((ub8)k[19] << 24) + ((ub8)k[20] << 32) +
               ((ub8)k[21] << 40) + ((ub8)k[22] << 48) + ((ub8)k[23] << 56));
         mix64(a, b, c);
         k += 24;
         len -= 24;
       }
     } else {
       while (len >= 24) /* aligned */
       {
         a += *(ub8 *)(k + 0);
         b += *(ub8 *)(k + 8);
         c += *(ub8 *)(k + 16);
         mix64(a, b, c);
         k += 24;
         len -= 24;
       }
     }
 
     /*------------------------------------- handle the last 23 bytes */
     c += length;
     switch (len) /* all the case statements fall through */
     {
       case 23:
         c += ((ub8)k[22] << 56);
         [[fallthrough]];
       case 22:
         c += ((ub8)k[21] << 48);
         [[fallthrough]];
       case 21:
         c += ((ub8)k[20] << 40);
         [[fallthrough]];
       case 20:
         c += ((ub8)k[19] << 32);
         [[fallthrough]];
       case 19:
         c += ((ub8)k[18] << 24);
         [[fallthrough]];
       case 18:
         c += ((ub8)k[17] << 16);
         [[fallthrough]];
       case 17:
         c += ((ub8)k[16] << 8);
         [[fallthrough]];
         /* the first byte of c is reserved for the length */
       case 16:
         b += ((ub8)k[15] << 56);
         [[fallthrough]];
       case 15:
         b += ((ub8)k[14] << 48);
         [[fallthrough]];
       case 14:
         b += ((ub8)k[13] << 40);
         [[fallthrough]];
       case 13:
         b += ((ub8)k[12] << 32);
         [[fallthrough]];
       case 12:
         b += ((ub8)k[11] << 24);
         [[fallthrough]];
       case 11:
         b += ((ub8)k[10] << 16);
         [[fallthrough]];
       case 10:
         b += ((ub8)k[9] << 8);
         [[fallthrough]];
       case 9:
         b += ((ub8)k[8]);
         [[fallthrough]];
       case 8:
         a += ((ub8)k[7] << 56);
         [[fallthrough]];
       case 7:
         a += ((ub8)k[6] << 48);
         [[fallthrough]];
       case 6:
         a += ((ub8)k[5] << 40);
         [[fallthrough]];
       case 5:
         a += ((ub8)k[4] << 32);
         [[fallthrough]];
       case 4:
         a += ((ub8)k[3] << 24);
         [[fallthrough]];
       case 3:
         a += ((ub8)k[2] << 16);
         [[fallthrough]];
       case 2:
         a += ((ub8)k[1] << 8);
         [[fallthrough]];
       case 1:
         a += ((ub8)k[0]);
         /* case 0: nothing left to add */
     }
     mix64(a, b, c);
     /*-------------------------------------------- report the result */
     return c;
   }

◆ httpGet()

unsigned long cond::httpGet	(	const std::string &	urlString,
		std::string &	info
	)

Definition at line 16 of file WebUtils.cc.

References mps_merge::body, getBodyCallback(), info(), runTheMatrix::ret, submitPVResolutionJobs::stderr, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cond::OMSServiceQuery::execute().

                                                                      {
     CURL* curl;
     CURLcode res;
     std::string body;
     char errbuf[CURL_ERROR_SIZE];
 
     curl = curl_easy_init();
     unsigned long ret = false;
     if (curl) {
       struct curl_slist* chunk = nullptr;
       chunk = curl_slist_append(chunk, "content-type:application/json");
       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
       curl_easy_setopt(curl, CURLOPT_URL, urlString.c_str());
       curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, getBodyCallback);
       curl_easy_setopt(curl, CURLOPT_WRITEDATA, &body);
       curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errbuf);
       res = curl_easy_perform(curl);
       curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &ret);
       if (CURLE_OK == res) {
         info = body;
       } else {
         size_t len = strlen(errbuf);
         fprintf(stderr, "\nlibcurl: (%d) ", res);
         if (len)
           fprintf(stderr, "%s%s", errbuf, ((errbuf[len - 1] != '\n') ? "\n" : ""));
         else
           fprintf(stderr, "%s\n", curl_easy_strerror(res));
       }
       curl_easy_cleanup(curl);
     }
     return ret;
   }

◆ invalidTime()

const Time_t cond::invalidTime ( 0 )

Referenced by cond::TimeTypeTraits< type >::specs().

◆ makeIov()

Iov_t cond::makeIov	(	cond::Time_t	since,
		const Hash &	payloadId
	)

Definition at line 20 of file CondDBPyWrappers.cc.

References runTheMatrix::ret, and SiStripBadComponentsDQMServiceTemplate_cfg::since.

Referenced by BOOST_PYTHON_MODULE().

                                                          {
     Iov_t ret;
     ret.since = since;
     ret.payloadId = payloadId;
     return ret;
   }

◆ parseLineForNamedParams()

void cond::parseLineForNamedParams	(	const std::string &	line,
		std::map< std::string, std::string > &	params
	)

Definition at line 58 of file DecodingKey.cc.

References B2GTnPMonitor_cfi::item, ItemSeparator, mps_splice::line, submitPVValidationJobs::params, str, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cond::auth::DecodingKey::createFromInputFile().

                                                                                             {
     std::stringstream str(line);
     std::string paramName("");
     std::string paramValue("");
     while (str.good()) {
       std::string item("");
       getline(str, item, ItemSeparator);
       if (item.size() > 3) {
         paramName = item.substr(0, 2);
         paramValue = item.substr(2);
         params.insert(std::make_pair(paramName, paramValue));
       }
     }
   }

◆ particleTypeFromString()

LHCInfo::ParticleType cond::particleTypeFromString ( const std::string & s_particle_type )

Definition at line 42 of file LHCInfoPopConSourceHandler.cc.

References mps_fire::i, LHCInfo::NONE, and s_particleTypeMap.

                                                                                {
     for (auto const& i : s_particleTypeMap)
       if (s_particle_type == i.first)
         return i.second;
     return LHCInfo::NONE;
   }

◆ pluginCategory()

const char * cond::pluginCategory ( )

Definition at line 64 of file ProxyFactory.cc.

64 { return "CondProxyFactory"; }

◆ randomChar()

char cond::randomChar ( )

Definition at line 37 of file DecodingKey.cc.

References b64str.

Referenced by cond::auth::KeyGenerator::make().

                     {
     int irand = ::rand() % (::strlen(b64str));
     return b64str[irand];
   }

◆ schemaLabel()

std::string cond::schemaLabel	(	const std::string &	serviceName,
		const std::string &	userName
	)

Definition at line 160 of file CredentialStore.cc.

References runTheMatrix::ret, serviceName, AlCaHLTBitMon_QueryRunRegistry::string, to_lower(), and EcalCondDBWriter_cfi::userName.

Referenced by cond::CredentialStore::createSchema(), cond::CredentialStore::importForPrincipal(), cond::CredentialStore::resetAdmin(), and schemaLabelForCredentialStore().

                                                                                  {
     std::string ret = userName;
     if (!serviceName.empty()) {
       ret += "@" + serviceName;
       ret = to_lower(ret);
     }
     return ret;
   }

◆ schemaLabelForCredentialStore()

std::string cond::schemaLabelForCredentialStore ( const std::string & connectionString )

Definition at line 169 of file CredentialStore.cc.

References l1RCTOmdsFedVectorProducer_cfi::connectionString, writedatasetfile::parser, schemaLabel(), serviceName, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                              {
     coral::URIParser parser;
     parser.setURI(connectionString);
     std::string serviceName = parser.hostName();
     std::string schemaName = parser.databaseOrSchemaName();
     return schemaLabel(serviceName, schemaName);
   }

◆ selectAuthorization()

bool cond::selectAuthorization	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		int	principalId,
		const std::string &	role,
		const std::string &	connectionString,
		AuthorizationData &	destination
	)

Definition at line 283 of file CredentialStore.cc.

References AUTH_ID_COL(), AUTH_KEY_COL(), AUTHORIZATION_TABLE(), C_ID_COL(), l1RCTOmdsFedVectorProducer_cfi::connectionString, HLTMuonOfflineAnalyzer_cff::destination, newFWLiteAna::found, P_ID_COL(), contentValuesFiles::query, ROLE_COL(), SCHEMA_COL(), AlCaHLTBitMon_QueryRunRegistry::string, tname(), and to_lower().

Referenced by setPermissionData().

                                                            {
     std::unique_ptr<coral::IQuery> query(schema.tableHandle(tname(AUTHORIZATION_TABLE, schemaVersion)).newQuery());
     coral::AttributeList readBuff;
     readBuff.extend<int>(AUTH_ID_COL);
     readBuff.extend<int>(C_ID_COL);
     readBuff.extend<std::string>(AUTH_KEY_COL);
     coral::AttributeList whereData;
     whereData.extend<int>(P_ID_COL);
     whereData.extend<std::string>(ROLE_COL);
     whereData.extend<std::string>(SCHEMA_COL);
     whereData[P_ID_COL].data<int>() = principalId;
     whereData[ROLE_COL].data<std::string>() = role;
     whereData[SCHEMA_COL].data<std::string>() = to_lower(connectionString);
     std::stringstream whereClause;
     whereClause << P_ID_COL << " = :" << P_ID_COL;
     whereClause << " AND " << ROLE_COL << " = :" << ROLE_COL;
     whereClause << " AND " << SCHEMA_COL << " = :" << SCHEMA_COL;
     query->defineOutput(readBuff);
     query->addToOutputList(AUTH_ID_COL);
     query->addToOutputList(C_ID_COL);
     query->addToOutputList(AUTH_KEY_COL);
     query->setCondition(whereClause.str(), whereData);
     coral::ICursor& cursor = query->execute();
     bool found = false;
     if (cursor.next()) {
       const coral::AttributeList& row = cursor.currentRow();
       destination.id = row[AUTH_ID_COL].data<int>();
       destination.connectionId = row[C_ID_COL].data<int>();
       destination.key = row[AUTH_KEY_COL].data<std::string>();
       found = true;
     }
     return found;
   }

◆ selectConnection()

bool cond::selectConnection	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		const std::string &	connectionLabel,
		CredentialData &	destination
	)

Definition at line 240 of file CredentialStore.cc.

References CONNECTION_ID_COL(), CONNECTION_KEY_COL(), CONNECTION_LABEL_COL(), CREDENTIAL_TABLE(), HLTMuonOfflineAnalyzer_cff::destination, newFWLiteAna::found, PASSWORD_COL(), contentValuesFiles::query, AlCaHLTBitMon_QueryRunRegistry::string, tname(), USERNAME_COL(), and VERIFICATION_KEY_COL().

Referenced by cond::CredentialStore::removeConnection(), cond::CredentialStore::setPermission(), updateConnectionData(), and cond::CredentialStore::updatePrincipal().

                                                      {
     std::unique_ptr<coral::IQuery> query(schema.tableHandle(tname(CREDENTIAL_TABLE, schemaVersion)).newQuery());
     coral::AttributeList readBuff;
     readBuff.extend<int>(CONNECTION_ID_COL);
     readBuff.extend<std::string>(USERNAME_COL);
     readBuff.extend<std::string>(PASSWORD_COL);
     readBuff.extend<std::string>(VERIFICATION_KEY_COL);
     readBuff.extend<std::string>(CONNECTION_KEY_COL);
     coral::AttributeList whereData;
     whereData.extend<std::string>(CONNECTION_LABEL_COL);
     whereData[CONNECTION_LABEL_COL].data<std::string>() = connectionLabel;
     std::string whereClause = CONNECTION_LABEL_COL + " = :" + CONNECTION_LABEL_COL;
     query->defineOutput(readBuff);
     query->addToOutputList(CONNECTION_ID_COL);
     query->addToOutputList(USERNAME_COL);
     query->addToOutputList(PASSWORD_COL);
     query->addToOutputList(VERIFICATION_KEY_COL);
     query->addToOutputList(CONNECTION_KEY_COL);
     query->setCondition(whereClause, whereData);
     coral::ICursor& cursor = query->execute();
     bool found = false;
     if (cursor.next()) {
       const coral::AttributeList& row = cursor.currentRow();
       destination.id = row[CONNECTION_ID_COL].data<int>();
       destination.userName = row[USERNAME_COL].data<std::string>();
       destination.password = row[PASSWORD_COL].data<std::string>();
       destination.verificationKey = row[VERIFICATION_KEY_COL].data<std::string>();
       destination.connectionKey = row[CONNECTION_KEY_COL].data<std::string>();
       found = true;
     }
     return found;
   }

◆ selectPrincipal()

bool cond::selectPrincipal	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		const std::string &	principal,
		PrincipalData &	destination
	)

Definition at line 198 of file CredentialStore.cc.

References ADMIN_KEY_COL(), AUTHENTICATION_TABLE(), HLTMuonOfflineAnalyzer_cff::destination, newFWLiteAna::found, PRINCIPAL_ID_COL(), PRINCIPAL_KEY_COL(), PRINCIPAL_NAME_COL(), contentValuesFiles::query, AlCaHLTBitMon_QueryRunRegistry::string, tname(), and VERIFICATION_COL().

Referenced by cond::CredentialStore::importForPrincipal(), cond::CredentialStore::removePrincipal(), cond::CredentialStore::resetAdmin(), cond::CredentialStore::setPermission(), cond::CredentialStore::startSession(), cond::CredentialStore::unsetPermission(), and updatePrincipalData().

                                                    {
     std::unique_ptr<coral::IQuery> query(schema.tableHandle(tname(AUTHENTICATION_TABLE, schemaVersion)).newQuery());
     coral::AttributeList readBuff;
     readBuff.extend<int>(PRINCIPAL_ID_COL);
     readBuff.extend<std::string>(VERIFICATION_COL);
     readBuff.extend<std::string>(PRINCIPAL_KEY_COL);
     readBuff.extend<std::string>(ADMIN_KEY_COL);
     coral::AttributeList whereData;
     whereData.extend<std::string>(PRINCIPAL_NAME_COL);
     whereData[PRINCIPAL_NAME_COL].data<std::string>() = principal;
     std::string whereClause = PRINCIPAL_NAME_COL + " = :" + PRINCIPAL_NAME_COL;
     query->defineOutput(readBuff);
     query->addToOutputList(PRINCIPAL_ID_COL);
     query->addToOutputList(VERIFICATION_COL);
     query->addToOutputList(PRINCIPAL_KEY_COL);
     query->addToOutputList(ADMIN_KEY_COL);
     query->setCondition(whereClause, whereData);
     coral::ICursor& cursor = query->execute();
     bool found = false;
     if (cursor.next()) {
       found = true;
       const coral::AttributeList& row = cursor.currentRow();
       destination.id = row[PRINCIPAL_ID_COL].data<int>();
       destination.verifKey = row[VERIFICATION_COL].data<std::string>();
       destination.principalKey = row[PRINCIPAL_KEY_COL].data<std::string>();
       destination.adminKey = row[ADMIN_KEY_COL].data<std::string>();
     }
     return found;
   }

◆ serialize()

template<typename T >

std::pair<Binary, Binary> cond::serialize ( const T & payload )

Definition at line 66 of file Serialization.h.

References MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, cond::StreamerInfo::jsonString(), jetsAK4_Puppi_cff::payload, runTheMatrix::ret, AlCaHLTBitMon_QueryRunRegistry::string, and throwException().

Referenced by cond::persistency::Session::storePayload< std::string >(), cond::persistency::Session::storePayload(), and RawEventFileWriterForBU::writeJsds().

                                                       {
     std::pair<Binary, Binary> ret;
     std::string streamerInfo(StreamerInfo::jsonString());
     try {
       // save data to buffers
       std::ostringstream dataBuffer;
       CondOutputArchive oa(dataBuffer);
       oa << payload;
       //TODO: avoid (2!!) copies
       ret.first.copy(dataBuffer.str());
       ret.second.copy(streamerInfo);
     } catch (const std::exception& e) {
       std::string em(e.what());
       throwException("Serialization failed: " + em + ". Serialization info:" + streamerInfo, "serialize");
     }
     return ret;
   }

◆ setPermissionData()

bool cond::setPermissionData	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		int	principalId,
		const std::string &	principalKey,
		const std::string &	role,
		const std::string &	connectionString,
		int	connectionId,
		const std::string &	connectionKey,
		std::stringstream &	log
	)

Definition at line 457 of file CredentialStore.cc.

References AUTH_ID_COL(), AUTH_KEY_COL(), AUTHORIZATION_TABLE(), cond::auth::Cipher::b64encrypt(), C_ID_COL(), l1RCTOmdsFedVectorProducer_cfi::connectionString, spr::find(), newFWLiteAna::found, getNextSequenceValue(), cond::AuthorizationData::id, dqm-mbProfile::log, GetRecoTauVFromDQM_MC_cff::next, P_ID_COL(), ROLE_COL(), cond::auth::ROLES, SCHEMA_COL(), selectAuthorization(), AlCaHLTBitMon_QueryRunRegistry::string, cond::persistency::throwException(), tname(), and to_lower().

Referenced by cond::CredentialStore::createSchema(), cond::CredentialStore::importForPrincipal(), cond::CredentialStore::resetAdmin(), cond::CredentialStore::setPermission(), and cond::CredentialStore::updatePrincipal().

                                                {
     if (cond::auth::ROLES.find(role) == cond::auth::ROLES.end()) {
       throwException(std::string("Role ") + role + " does not exists.", "CredentialStore::setPermission");
     }
     auth::Cipher cipher(principalKey);
     std::string encryptedConnectionKey = cipher.b64encrypt(connectionKey);
     AuthorizationData authData;
     bool found = selectAuthorization(schemaVersion, schema, principalId, role, connectionString, authData);
 
     std::string authorization_table_name = tname(AUTHORIZATION_TABLE, schemaVersion);
     coral::ITableDataEditor& editor = schema.tableHandle(authorization_table_name).dataEditor();
     if (found) {
       log << "Updating permission for principal id " << principalId << " to access resource " << connectionString
           << " with role " << role << std::endl;
       coral::AttributeList updateData;
       updateData.extend<int>(AUTH_ID_COL);
       updateData.extend<int>(C_ID_COL);
       updateData.extend<std::string>(AUTH_KEY_COL);
       updateData[AUTH_ID_COL].data<int>() = authData.id;
       updateData[C_ID_COL].data<int>() = connectionId;
       updateData[AUTH_KEY_COL].data<std::string>() = encryptedConnectionKey;
       std::string setCl = C_ID_COL + " = :" + C_ID_COL + ", " + AUTH_KEY_COL + " = :" + AUTH_KEY_COL;
       std::string whereCl = AUTH_ID_COL + " = :" + AUTH_ID_COL;
       editor.updateRows(setCl, whereCl, updateData);
     } else {
       int next = -1;
       if (!getNextSequenceValue(schemaVersion, schema, authorization_table_name, next))
         throwException("Can't find " + authorization_table_name + " sequence.", "CredentialStore::setPermission");
       log << "Setting permission for principal id " << principalId << " to access resource " << connectionString
           << " with role " << role << std::endl;
       coral::AttributeList insertData;
       insertData.extend<int>(AUTH_ID_COL);
       insertData.extend<int>(P_ID_COL);
       insertData.extend<std::string>(ROLE_COL);
       insertData.extend<std::string>(SCHEMA_COL);
       insertData.extend<std::string>(AUTH_KEY_COL);
       insertData.extend<int>(C_ID_COL);
       insertData[AUTH_ID_COL].data<int>() = next;
       insertData[P_ID_COL].data<int>() = principalId;
       insertData[ROLE_COL].data<std::string>() = role;
       insertData[SCHEMA_COL].data<std::string>() = to_lower(connectionString);
       insertData[AUTH_KEY_COL].data<std::string>() = encryptedConnectionKey;
       insertData[C_ID_COL].data<int>() = connectionId;
       editor.insertRow(insertData);
     }
     return true;
   }

◆ synchronizationTypeFromName()

SynchronizationType cond::synchronizationTypeFromName ( const std::string & name )

Definition at line 47 of file Types.cc.

References mps_fire::i, Skims_PA_cff::name, s_obsoleteSynchronizationTypeArray, s_synchronizationTypeArray, and throwException().

Referenced by cond::persistency::GetFromRow< cond::SynchronizationType >::operator()().

                                                                          {
     for (auto const &i : s_synchronizationTypeArray)
       if (name == i.first)
         return i.second;
     for (auto const &i : s_obsoleteSynchronizationTypeArray)
       if (name == i.first)
         return i.second;
     throwException("SynchronizationType \"" + name + "\" is unknown.", "synchronizationTypeFromName");
   }

◆ synchronizationTypeNames()

std::string cond::synchronizationTypeNames ( SynchronizationType type )

Definition at line 45 of file Types.cc.

References s_synchronizationTypeArray.

Referenced by cond::persistency::f_add_attribute(), and cond::persistency::IOVEditor::flush().

45 { return s_synchronizationTypeArray[type].first; }

cond::s_synchronizationTypeArray

static std::pair< const char *, SynchronizationType > s_synchronizationTypeArray[]

Definition: Types.cc:29

gainCalibHelper::gainCalibPI::type

type

Definition: SiPixelGainCalibHelper.h:40

◆ throwException()

void cond::throwException	(	const std::string &	message,
		const std::string &	methodName
	)

Definition at line 18 of file Exception.cc.

                                                                              {
     throw Exception(message, methodName);
   }

◆ TIMELIMIT()

const Time_t cond::TIMELIMIT ( std::numeric_limits< Time_t > ::max() )

Referenced by CondDBESSource::setIntervalFor().

◆ timeTypeNames()

std::string const & cond::timeTypeNames ( int i )

Definition at line 11 of file Time.cc.

References mps_fire::i, DTRecHitClients_cfi::local, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CondDBESSource::setIntervalFor(), and cond::TimeTypeTraits< type >::specs().

                                         {
     static const std::string local[] = {"runnumber", "timestamp", "lumiid", "hash", "userid"};
     return local[i];
   }

◆ updateConnectionData()

std::pair<int, std::string> cond::updateConnectionData	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		const std::string &	adminKey,
		const std::string &	connectionLabel,
		const std::string &	userName,
		const std::string &	password,
		bool	forceUpdate,
		std::stringstream &	log
	)

Definition at line 513 of file CredentialStore.cc.

References cond::auth::Cipher::b64decrypt(), cond::auth::Cipher::b64encrypt(), cond::auth::COND_DB_KEY_SIZE, CONNECTION_ID_COL(), CONNECTION_KEY_COL(), CONNECTION_LABEL_COL(), cond::CredentialData::connectionKey, CREDENTIAL_TABLE(), newFWLiteAna::found, relval_steps::gen(), getNextSequenceValue(), cond::CredentialData::id, dqm-mbProfile::log, EcalCondDBWriter_cfi::password, PASSWORD_COL(), selectConnection(), AlCaHLTBitMon_QueryRunRegistry::string, cond::persistency::throwException(), tname(), EcalCondDBWriter_cfi::userName, USERNAME_COL(), VERIFICATION_KEY_COL(), and cond::CredentialData::verificationKey.

Referenced by cond::CredentialStore::createSchema(), cond::CredentialStore::importForPrincipal(), cond::CredentialStore::resetAdmin(), and cond::CredentialStore::updateConnection().

                                                                          {
     CredentialData credsData;
     bool found = selectConnection(schemaVersion, schema, connectionLabel, credsData);
     int connId = credsData.id;
 
     auth::Cipher adminCipher(adminKey);
     std::string connectionKey("");
     std::string credential_table_name = tname(CREDENTIAL_TABLE, schemaVersion);
     coral::ITableDataEditor& editor = schema.tableHandle(credential_table_name).dataEditor();
     if (found) {
       connectionKey = adminCipher.b64decrypt(credsData.connectionKey);
       auth::Cipher cipher(connectionKey);
       std::string verificationKey = cipher.b64decrypt(credsData.verificationKey);
       if (verificationKey != connectionLabel) {
         throwException("Decoding of connection key failed.", "CredentialStore::updateConnection");
       }
       if (forceUpdate) {
         std::string encryptedUserName = cipher.b64encrypt(userName);
         std::string encryptedPassword = cipher.b64encrypt(password);
         log << "Forcing update of connection " << connectionLabel << std::endl;
         coral::AttributeList updateData;
         updateData.extend<int>(CONNECTION_ID_COL);
         updateData.extend<std::string>(USERNAME_COL);
         updateData.extend<std::string>(PASSWORD_COL);
         updateData[CONNECTION_ID_COL].data<int>() = connId;
         updateData[USERNAME_COL].data<std::string>() = encryptedUserName;
         updateData[PASSWORD_COL].data<std::string>() = encryptedPassword;
         std::stringstream setCl;
         setCl << USERNAME_COL << " = :" << USERNAME_COL;
         setCl << ", " << PASSWORD_COL << " = :" << PASSWORD_COL;
         std::string whereCl = CONNECTION_ID_COL + " = :" + CONNECTION_ID_COL;
         editor.updateRows(setCl.str(), whereCl, updateData);
       }
     } else {
       auth::KeyGenerator gen;
       connectionKey = gen.make(auth::COND_DB_KEY_SIZE);
       auth::Cipher cipher(connectionKey);
       std::string encryptedUserName = cipher.b64encrypt(userName);
       std::string encryptedPassword = cipher.b64encrypt(password);
       std::string encryptedLabel = cipher.b64encrypt(connectionLabel);
 
       if (!getNextSequenceValue(schemaVersion, schema, credential_table_name, connId))
         throwException("Can't find " + credential_table_name + " sequence.", "CredentialStore::updateConnection");
       log << "Creating new connection " << connectionLabel << std::endl;
       coral::AttributeList insertData;
       insertData.extend<int>(CONNECTION_ID_COL);
       insertData.extend<std::string>(CONNECTION_LABEL_COL);
       insertData.extend<std::string>(USERNAME_COL);
       insertData.extend<std::string>(PASSWORD_COL);
       insertData.extend<std::string>(VERIFICATION_KEY_COL);
       insertData.extend<std::string>(CONNECTION_KEY_COL);
       insertData[CONNECTION_ID_COL].data<int>() = connId;
       insertData[CONNECTION_LABEL_COL].data<std::string>() = connectionLabel;
       insertData[USERNAME_COL].data<std::string>() = encryptedUserName;
       insertData[PASSWORD_COL].data<std::string>() = encryptedPassword;
       insertData[VERIFICATION_KEY_COL].data<std::string>() = encryptedLabel;
       insertData[CONNECTION_KEY_COL].data<std::string>() = adminCipher.b64encrypt(connectionKey);
       ;
       editor.insertRow(insertData);
     }
     return std::make_pair(connId, connectionKey);
   }

◆ updatePrincipalData()

std::pair<int, std::string> cond::updatePrincipalData	(	const std::string &	schemaVersion,
		coral::ISchema &	schema,
		const std::string &	authenticationKey,
		const std::string &	principalName,
		const std::string &	adminKey,
		bool	init,
		std::stringstream &	log
	)

Parameters

init = false *

Definition at line 394 of file CredentialStore.cc.

References ADMIN_KEY_COL(), cond::PrincipalData::adminKey, AUTHENTICATION_TABLE(), cond::auth::Cipher::b64decrypt(), cond::auth::Cipher::b64encrypt(), cond::auth::COND_DB_KEY_SIZE, newFWLiteAna::found, relval_steps::gen(), getNextSequenceValue(), cond::PrincipalData::id, dqm-mbProfile::log, PRINCIPAL_ID_COL(), PRINCIPAL_KEY_COL(), PRINCIPAL_NAME_COL(), selectPrincipal(), AlCaHLTBitMon_QueryRunRegistry::string, cond::persistency::throwException(), tname(), and VERIFICATION_COL().

Referenced by cond::CredentialStore::createSchema(), cond::CredentialStore::resetAdmin(), and cond::CredentialStore::updatePrincipal().

                                                                         {
     PrincipalData princData;
     bool found = selectPrincipal(schemaVersion, schema, principalName, princData);
 
     auth::Cipher cipher0(authenticationKey);
     auth::Cipher cipher1(adminKey);
 
     std::string verifStr = cipher0.b64encrypt(principalName);
     std::string principalKey("");
     int principalId = princData.id;
 
     std::string authentication_table_name = tname(AUTHENTICATION_TABLE, schemaVersion);
 
     coral::ITableDataEditor& editor = schema.tableHandle(authentication_table_name).dataEditor();
     if (found) {
       log << "Updating existing principal " << principalName << " (id: " << principalId << " )" << std::endl;
       principalKey = cipher1.b64decrypt(princData.adminKey);
       coral::AttributeList updateData;
       updateData.extend<int>(PRINCIPAL_ID_COL);
       updateData.extend<std::string>(VERIFICATION_COL);
       updateData.extend<std::string>(PRINCIPAL_KEY_COL);
       updateData.extend<std::string>(ADMIN_KEY_COL);
       updateData[PRINCIPAL_ID_COL].data<int>() = principalId;
       updateData[VERIFICATION_COL].data<std::string>() = verifStr;
       updateData[PRINCIPAL_KEY_COL].data<std::string>() = cipher0.b64encrypt(principalKey);
       updateData[ADMIN_KEY_COL].data<std::string>() = cipher1.b64encrypt(principalKey);
       std::stringstream setClause;
       setClause << VERIFICATION_COL << " = :" << VERIFICATION_COL << ", ";
       setClause << PRINCIPAL_KEY_COL << " = :" << PRINCIPAL_KEY_COL << ", ";
       setClause << ADMIN_KEY_COL << " = :" << ADMIN_KEY_COL;
       std::string whereClause = PRINCIPAL_ID_COL + " = :" + PRINCIPAL_ID_COL;
       editor.updateRows(setClause.str(), whereClause, updateData);
     } else {
       if (init) {
         principalKey = adminKey;
       } else {
         auth::KeyGenerator gen;
         principalKey = gen.make(auth::COND_DB_KEY_SIZE);
       }
       coral::ITableDataEditor& editor0 = schema.tableHandle(authentication_table_name).dataEditor();
 
       if (!getNextSequenceValue(schemaVersion, schema, authentication_table_name, principalId))
         throwException("Can't find " + authentication_table_name + " sequence.", "CredentialStore::updatePrincipal");
       log << "Creating new principal " << principalName << " (id: " << principalId << " )" << std::endl;
       coral::AttributeList authData;
       editor0.rowBuffer(authData);
       authData[PRINCIPAL_ID_COL].data<int>() = principalId;
       authData[PRINCIPAL_NAME_COL].data<std::string>() = principalName;
       authData[VERIFICATION_COL].data<std::string>() = verifStr;
       authData[PRINCIPAL_KEY_COL].data<std::string>() = cipher0.b64encrypt(principalKey);
       authData[ADMIN_KEY_COL].data<std::string>() = cipher1.b64encrypt(principalKey);
       editor0.insertRow(authData);
     }
 
     return std::make_pair(principalId, principalKey);
   }

Variable Documentation

◆ HASH_SIZE

constexpr unsigned int cond::HASH_SIZE = 40

static

Definition at line 44 of file Types.h.

◆ s_fillTypeMap

const std::pair<const char*, LHCInfo::FillType> cond::s_fillTypeMap[]

static

Initial value:

= {std::make_pair("PROTONS", LHCInfo::PROTONS),
                                                                            std::make_pair("IONS", LHCInfo::IONS),
                                                                            std::make_pair("COSMICS", LHCInfo::COSMICS),
                                                                            std::make_pair("GAP", LHCInfo::GAP)}

Definition at line 23 of file LHCInfoPopConSourceHandler.cc.

Referenced by fillTypeFromString().

◆ s_obsoleteSynchronizationTypeArray

std::pair<const char *, SynchronizationType> cond::s_obsoleteSynchronizationTypeArray[]

static

Initial value:

= {
      std::make_pair("Offline", SYNCH_OFFLINE),
      std::make_pair("HLT", SYNCH_HLT),
      std::make_pair("Prompt", SYNCH_PROMPT),
      std::make_pair("Pcl", SYNCH_PCL)}

Definition at line 40 of file Types.cc.

Referenced by synchronizationTypeFromName().

◆ s_particleTypeMap

const std::pair<const char*, LHCInfo::ParticleType> cond::s_particleTypeMap[]

static

Initial value:

= {
      std::make_pair("PROTON", LHCInfo::PROTON),
      std::make_pair("PB82", LHCInfo::PB82),
      std::make_pair("AR18", LHCInfo::AR18),
      std::make_pair("D", LHCInfo::D),
      std::make_pair("XE54", LHCInfo::XE54)}

Definition at line 28 of file LHCInfoPopConSourceHandler.cc.

Referenced by particleTypeFromString().

◆ s_synchronizationTypeArray

std::pair<const char *, SynchronizationType> cond::s_synchronizationTypeArray[]

static

Initial value:

= {
      std::make_pair("any", SYNCH_ANY),
      std::make_pair("validation", SYNCH_VALIDATION),
      std::make_pair("offline", SYNCH_OFFLINE),
      std::make_pair("mc", SYNCH_MC),
      std::make_pair("runmc", SYNCH_RUNMC),
      std::make_pair("hlt", SYNCH_HLT),
      std::make_pair("express", SYNCH_EXPRESS),
      std::make_pair("prompt", SYNCH_PROMPT),
      std::make_pair("pcl", SYNCH_PCL)}

Definition at line 29 of file Types.cc.

Referenced by synchronizationTypeFromName(), and synchronizationTypeNames().

◆ TIMETYPE_LIST_MAX

const unsigned int cond::TIMETYPE_LIST_MAX = 5

Definition at line 20 of file Time.h.

Referenced by findSpecs().

◆ timeTypeList

const cond::TimeType cond::timeTypeList = {runnumber, timestamp, lumiid, hash, userid}

Definition at line 7 of file Time.cc.

◆ timeTypeSpecs

const TimeTypeSpecs cond::timeTypeSpecs

Initial value:

= {TimeTypeTraits<runnumber>::specs(),
                                         TimeTypeTraits<timestamp>::specs(),
                                         TimeTypeTraits<lumiid>::specs(),
                                         TimeTypeTraits<hash>::specs(),
                                         TimeTypeTraits<userid>::specs()}

Definition at line 16 of file Time.cc.

Referenced by FastSiPixelFEDChannelContainerFromQuality::analyze(), MCMisalignmentScaler::analyze(), MillePedeAlignmentAlgorithm::areIOVsSpecified(), cond::service::PoolDBOutputService::beginOfTime(), SiStripLorentzAngleCalibration::beginRun(), SiPixelLorentzAngleCalibration::beginRun(), MillePedeAlignmentAlgorithm::beginRun(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), cond::service::PoolDBOutputService::endOfTime(), findSpecs(), MillePedeAlignmentAlgorithm::initialize(), align::makeNonOverlappingRunRanges(), align::makeUniqueRunRanges(), CondDBESSource::setIntervalFor(), cond::service::PoolDBOutputService::Record::timetypestr(), and CreateIdealTkAlRecords::writeToDB().

◆ timeTypeValues

const cond::TimeType cond::timeTypeValues = {runnumber, timestamp, lumiid, hash, userid}

Definition at line 9 of file Time.cc.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ CondInputArchive

◆ CondOutputArchive

◆ CoralServicePluginFactory

◆ Exception

◆ Hash

◆ ProxyFactory

◆ Time_t

◆ uint64_t

◆ UnpackedTime

◆ ValidityInterval

Enumeration Type Documentation

◆ SynchronizationType

◆ TimeType

Function Documentation

◆ boost_version_label()

◆ createPayload()

◆ createPayload< HcalCalibrationQIEData >()

◆ createPayload< std::string >()

◆ default_deserialize()

◆ deserialize()

◆ deserialize< BaseKeyed >()

◆ deserialize< condex::Efficiency >()

◆ deserialize< CSCReadoutMapping >()

◆ deserialize< CSCReadoutMappingForSliceTest >()

◆ deserialize< PerformancePayload >()

◆ fillTypeFromString()

◆ findSpecs()

◆ getAuthorizationEntries()

◆ getBodyCallback()

◆ getch()

◆ getDbCredentials()

◆ getLastLumiFromOMS()

◆ getLatestLumiFromFile()

◆ getLoginName()

◆ getNextSequenceValue()

◆ getpass()

◆ getpassForUser()

◆ hash64()

◆ httpGet()

◆ invalidTime()

◆ makeIov()

◆ parseLineForNamedParams()

◆ particleTypeFromString()

◆ pluginCategory()

◆ randomChar()

◆ schemaLabel()

◆ schemaLabelForCredentialStore()

◆ selectAuthorization()

◆ selectConnection()

◆ selectPrincipal()

◆ serialize()

◆ setPermissionData()

◆ synchronizationTypeFromName()

◆ synchronizationTypeNames()

◆ throwException()

◆ TIMELIMIT()

◆ timeTypeNames()

◆ updateConnectionData()

◆ updatePrincipalData()

Variable Documentation

◆ HASH_SIZE

◆ s_fillTypeMap

◆ s_obsoleteSynchronizationTypeArray

◆ s_particleTypeMap

◆ s_synchronizationTypeArray

◆ TIMETYPE_LIST_MAX

◆ timeTypeList

◆ timeTypeSpecs

◆ timeTypeValues