DataListenerSvc Class Reference

DataListenerSvc inherits from IMonitorSvc and allows the GAUDI user to monitor variables declared in an algorithm. More...

#include <bking/DataListenerSvc.h>

Inheritance diagram for DataListenerSvc:

[legend]

Collaboration diagram for DataListenerSvc:

[legend]

List of all members.

Public Member Functions
	DataListenerSvc (const std::string &name, ISvcLocator *sl)
virtual	~DataListenerSvc ()
StatusCode	initialize ()
StatusCode	finalize ()
void	declareInfo (const std::string &name, const bool &var, const std::string &desc, const IInterface *owner)
	Declare monitoring information.
void	declareInfo (const std::string &name, const int &var, const std::string &desc, const IInterface *owner)
void	declareInfo (const std::string &name, const long &var, const std::string &desc, const IInterface *owner)
void	declareInfo (const std::string &name, const double &var, const std::string &desc, const IInterface *owner)
void	declareInfo (const std::string &name, const std::string &var, const std::string &desc, const IInterface *owner)
void	declareInfo (const std::string &name, const std::pair< double, double > &var, const std::string &desc, const IInterface *owner)
void	declareInfo (const std::string &name, const AIDA::IBaseHistogram var, const std::string &desc, const IInterface owner)
void	declareInfo (const std::string &name, const StatEntity &var, const std::string &desc, const IInterface *owner)
void	declareInfo (const std::string &name, const std::string &format, const void var, int size, const std::string &desc, const IInterface owner)
void	undeclareInfo (const std::string &name, const IInterface *owner)
	Undeclare monitoring information.
void	undeclareAll (const IInterface *owner)
	Undeclare monitoring information.
virtual void	handle (const Incident &)
	Implementation of the IIncidentListener.h virtual method.
std::set< std::string > *	getInfos (const IInterface *owner=0)
	Get the names for all declared monitoring informations for a given owner.
void	apmSend (char clusterName, char moduleName, char *key, double val)
	Send (key,value) pairs to MonALISA server.
void	apmSend (char clusterName, char moduleName, char *key, int val)
	Send a (char*,int) pair to MonALISA.
void	apmSend (char clusterName, char moduleName, char *key, long val)
	Send a (char*,long) pair to MonALISA.
void	apmSend (char clusterName, char moduleName, char *key, bool val)
	Send a (char*,bool) pair to MonALISA.
void	apmSend (char clusterName, char moduleName, char key, char val)
	Send a (char,char) pair to MonALISA.
Private Types
typedef std::pair< std::string, ValueMap >	Entry
typedef std::map< const IInterface *, std::set < std::string > >	InfoNamesMap
typedef std::map< std::string, ValueMap >	ValNamesMap
Private Member Functions
void	writeMap (ValNamesMap , const Incident &, std::ofstream )
void	writeXML (ValNamesMap , const Incident &, std::ofstream )
std::string	resizeString (const std::string, const unsigned int)
std::string	stringConverter (const int convertee)
std::string	stringConverter (const double convertee)
std::string	stringConverter (const bool convertee)
std::string	stringConverter (const long convertee)
void	sendData (ValNamesMap *)
	MonALISA sender method to send Data to MonALISA server.
std::string	infoOwnerName (const IInterface *owner)
Private Attributes
ApMon *	apm
ValueMap	m_ValueMap
ValueMap	m_ValueMapTemp
time_t	rawTime
time_t	rawTime2
char	buffer [50]
char	buffer2 [50]
std::string	timeDate
std::string	timeDate2
std::string	valToWrite
InfoNamesMap	m_InfoNamesMap
InfoNamesMap::iterator	m_InfoNamesMapIt
ValNamesMap	m_ValNamesMap
ValNamesMap::iterator	m_ValNamesMapIt
XmlCode	xml
IIncidentSvc *	m_incidentSvc
FILE *	MonitorLog
std::ofstream	Log4
std::ofstream	XMLLog
int	FreqCriterion
int	m_EventFrequency
std::map< std::string, std::string >	m_infoDescriptions
int	m_MLjobID
int	m_MLEventFrequency
std::string	m_MLClusterName
std::string	m_ApMonSettingsFile
std::string	jobIDString
int	m_MonALISAMonitoring
int	m_XMLMonitoring
int	m_FileMonitoring
char *	keyToSend

Detailed Description

DataListenerSvc inherits from IMonitorSvc and allows the GAUDI user to monitor variables declared in an algorithm.

DataListenerSvc generates XML files on the individual machines where the algorithm is run, which can then be parsed by e.g. GANGA and sent to a monitoring server such as MonALISA. XML files are written at a frequency specified by the user and are consumed as they are created when used within GANGA.

Usage

In Algorithm header file

Include DataListenerSvc include DataListenerSvc/DataListenerSvc.h
define IMonitorSvc object: e.g. IMonitorSvc *m_DataListenerSvcSvc;

In Algorithm cpp file

instantiate IMonitorSvc object: e.g. sc = service("DataListenerSvc", m_DataListenerSvcSvc, true);
declare monitored variables: e.g. m_DataListenerSvcSvc->declareInfo("Psi ID", m_jPsiID, "The Psi ID", this); (for variable m_jPsiID)

Supports declaration of variables of type: int, long, bool, double, string

In GAUDI options file

Include DLL in ApplicationMgr.DLLs DataListenerSvc
Include Service in ApplicationMgr.ExtSvc DataListenerSvc/DataListenerSvc
Set job options e.g. DataListenerSvc.EventFrequency = 50

Job options available

Parameters:

EventFrequency

How data is sent to - default is every 100 events

XML file format

XML tag format is the following:

Opening parent tags of the form:

<?xml version="1.0" encoding="ASCII" standalone="yes"?>
<Results Time="Tue Aug 22 10:17:22 2006">

<Run>

With then an entry for each monitored variable of the form:

	`<Incident>`
		`<IncType>EndEvent </IncType>` `<IncSource>EventLoopMgr </IncSource>` `<VarName>Psi ID </VarName>` `<Value Result="8">443</Value>`
	`</Incident>`

Parameters:

	IncType	What type of incident triggered the handle method
	IncSource	What triggered the IIncident handle method
	VarName	Name of the variable monitored
	Value	Value of the variable
	Result	Number of times the variable already read

Author:: Ben KING

Date:: 2006-08-24

Definition at line 112 of file DataListenerSvc.h.

Member Typedef Documentation

typedef std::pair< std::string, ValueMap > DataListenerSvc::Entry [private]

Definition at line 213 of file DataListenerSvc.h.

typedef std::map<const IInterface*, std::set<std::string> > DataListenerSvc::InfoNamesMap [private]

Definition at line 214 of file DataListenerSvc.h.

typedef std::map< std::string, ValueMap > DataListenerSvc::ValNamesMap [private]

Definition at line 216 of file DataListenerSvc.h.

Constructor & Destructor Documentation

DataListenerSvc::DataListenerSvc	(	const std::string &	name,
		ISvcLocator *	sl
	)

Definition at line 59 of file DataListenerSvc.cpp.

00060   : base_class(name, sl) {
00061 
00062   declareProperty ("EventFrequency", m_EventFrequency=defaultFrequency);
00063   declareProperty ("MLEventFrequency", m_MLEventFrequency=defaultMLFrequency);
00064   declareProperty ("MLjobID", m_MLjobID=defaultjobID);
00065   declareProperty ("MLClusterName", m_MLClusterName=defaultClusterName);
00066   declareProperty ("MonALISAMonitoring", m_MonALISAMonitoring=defaultMonALISAMonitoring);
00067   declareProperty ("ApMonSource", m_ApMonSettingsFile=defaultApMonSettingsFile);
00068 
00069   declareProperty ("XMLMonitoring", m_XMLMonitoring=defaultXMLMonitoring);
00070   declareProperty ("FileMonitoring", m_FileMonitoring=defaultFileMonitoring);
00071 
00072 }

virtual DataListenerSvc::~DataListenerSvc ( ) [inline, virtual]

Definition at line 116 of file DataListenerSvc.h.

00116 {}

Member Function Documentation

void DataListenerSvc::apmSend	(	char *	clusterName,
		char *	moduleName,
		char *	key,
		char *	val
	)

Send a (char*,char*) pair to MonALISA.

Definition at line 680 of file DataListenerSvc.cpp.

00682 {
00683   MsgStream msg(msgSvc(),"DataListenerSvc");
00684   msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00685   try {
00686     DataListenerSvc::apm->sendParameter( clusterName, clusterNode, key, val);
00687     msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00688     msg << MSG::INFO << "Sent parameters to MonALISA sever:"
00689         << m_MLClusterName << "->"
00690         << jobIDString.c_str() << "->"
00691         << key << ":" << val << endmsg;
00692   } catch (std::runtime_error &e){
00693     msg << MSG::WARNING << "WARNING sending to ApMon:\t" << e.what() << endmsg;
00694   }
00695 }

void DataListenerSvc::apmSend	(	char *	clusterName,
		char *	moduleName,
		char *	key,
		bool	val
	)

Send a (char*,bool) pair to MonALISA.

Definition at line 663 of file DataListenerSvc.cpp.

00665 {
00666   MsgStream msg(msgSvc(),"DataListenerSvc");
00667   msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00668   try {
00669     DataListenerSvc::apm->sendParameter( clusterName, clusterNode, key, val);
00670     msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00671     msg << MSG::INFO << "Sent parameters to MonALISA sever:"
00672         << m_MLClusterName << "->"
00673         << jobIDString.c_str() << "->"
00674         << key << ":" << val << endmsg;
00675   } catch (std::runtime_error &e){
00676     msg << MSG::WARNING << "WARNING sending to ApMon:\t" << e.what() << endmsg;
00677   }
00678 }

void DataListenerSvc::apmSend	(	char *	clusterName,
		char *	moduleName,
		char *	key,
		long	val
	)

Send a (char*,long) pair to MonALISA.

Definition at line 643 of file DataListenerSvc.cpp.

00645 {
00646   MsgStream msg(msgSvc(),"DataListenerSvc");
00647   msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00648   double temp;
00649   temp = *(double*)val;
00650 
00651   try {
00652     DataListenerSvc::apm->sendParameter( clusterName, clusterNode, key, temp);
00653     msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00654     msg << MSG::INFO << "Sent parameters to MonALISA sever:"
00655         << m_MLClusterName << "->"
00656         << jobIDString.c_str() << "->"
00657         << key << ":" << val << endmsg;
00658   } catch (std::runtime_error &e){
00659     msg << MSG::WARNING << "WARNING sending to ApMon:\t" << e.what() << endmsg;
00660   }
00661 }

void DataListenerSvc::apmSend	(	char *	clusterName,
		char *	moduleName,
		char *	key,
		int	val
	)

Send a (char*,int) pair to MonALISA.

Definition at line 626 of file DataListenerSvc.cpp.

00628 {
00629   MsgStream msg(msgSvc(),"DataListenerSvc");
00630   msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00631   try {
00632     DataListenerSvc::apm->sendParameter( clusterName, clusterNode, key, val);
00633     msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00634     msg << MSG::INFO << "Sent parameters to MonALISA sever:"
00635         << m_MLClusterName << "->"
00636         << jobIDString.c_str() << "->"
00637         << key << ":" << val << endmsg;
00638   } catch(std::runtime_error &e) {
00639     msg << MSG::WARNING << "WARNING sending to ApMon:\t" << e.what() << endmsg;
00640   }
00641 }

void DataListenerSvc::apmSend	(	char *	clusterName,
		char *	moduleName,
		char *	key,
		double	val
	)

Send (key,value) pairs to MonALISA server.

Parameters:

	clusterName	Name of cluster where information will be stored
	moduleName	Name of module where information will be stored
	key	Key of the (key,value) pair sent to MonALISA
	value	Value of the (key,value) pair sent to MonALISA Send a (char*,double) pair to MonALISA

Definition at line 608 of file DataListenerSvc.cpp.

00610 {
00611   MsgStream msg(msgSvc(),"DataListenerSvc");
00612   msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00613 
00614   try {
00615     DataListenerSvc::apm->sendParameter( clusterName, clusterNode, key, val);
00616     msg << MSG::DEBUG << "ApMon instantiated" << endmsg;
00617     msg << MSG::INFO << "Sent parameters to MonALISA sever:"
00618         << m_MLClusterName << "->"
00619         << jobIDString.c_str() << "->"
00620         << key << ":" << val << endmsg;
00621   } catch(std::runtime_error &e) {
00622     msg << MSG::WARNING << "WARNING sending to ApMon:\t" << e.what() << endmsg;
00623   }
00624 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const std::string &	format,
		const void *	var,
		int	size,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 299 of file DataListenerSvc.cpp.

00305 {
00306 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const StatEntity &	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 285 of file DataListenerSvc.cpp.

00289 {
00290 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const AIDA::IBaseHistogram *	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 292 of file DataListenerSvc.cpp.

00296 {
00297 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const std::pair< double, double > &	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 278 of file DataListenerSvc.cpp.

00282 {
00283 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const std::string &	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 260 of file DataListenerSvc.cpp.

00264 {
00265   ValueMap::m_type vartype;
00266   vartype = ValueMap::m_string;
00267 
00268   MsgStream msg(msgSvc(),"DataListenerSvc");
00269 
00270   m_ValueMap.set_ptr(  static_cast <void*> (const_cast <std::string*> (&var) )  );  m_ValueMap.set_ptrType(vartype);
00271 
00272   Entry p1(name, m_ValueMap);
00273 
00274   m_ValNamesMap.insert(p1);
00275 
00276 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const double &	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 183 of file DataListenerSvc.cpp.

00186 {
00187   ValueMap::m_type vartype;
00188   vartype = ValueMap::m_double;
00189 
00190   MsgStream msg(msgSvc(),"DataListenerSvc");
00191 
00192   // In the ValueMap, store the pointer to the data (converted to void*)
00193   // and also store the pointer type (with an enum) so it can be converted back
00194   m_ValueMap.set_ptr(  static_cast <void*> (const_cast <double*> (&var) )  );
00195   m_ValueMap.set_ptrType(vartype);
00196 
00197   Entry p1(name, m_ValueMap);
00198 
00199   // m_ValNamesMap is then composed of n (variable Name: ValueMap) pairs
00200   m_ValNamesMap.insert(p1);
00201 
00202 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const long &	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 204 of file DataListenerSvc.cpp.

00207 {
00208 
00209   ValueMap::m_type vartype;
00210   vartype = ValueMap::m_long;
00211 
00212   MsgStream msg(msgSvc(),"DataListenerSvc");
00213 
00214   m_ValueMap.set_ptr(  static_cast <void*> (const_cast <long*> (&var) )  );
00215   m_ValueMap.set_ptrType(vartype);
00216 
00217   Entry p1(name, m_ValueMap);
00218 
00219   m_ValNamesMap.insert(p1);
00220 
00221 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const int &	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Definition at line 223 of file DataListenerSvc.cpp.

00226 {
00227   ValueMap::m_type vartype;
00228   vartype = ValueMap::m_int;
00229 
00230   MsgStream msg(msgSvc(),"DataListenerSvc");
00231 
00232   m_ValueMap.set_ptr(  static_cast <void*> (const_cast <int*> (&var) )  );
00233   m_ValueMap.set_ptrType(vartype);
00234 
00235   Entry p1(name, m_ValueMap);
00236 
00237   m_ValNamesMap.insert(p1);
00238 
00239 }

void DataListenerSvc::declareInfo	(	const std::string &	name,
		const bool &	var,
		const std::string &	desc,
		const IInterface *	owner
	)

Declare monitoring information.

Parameters:

	name	Monitoring information name known to the external system
	var	Monitoring Listener address
	desc	Textual description
	owner	Owner identifier of the monitoring information (needed to perform clean up

Definition at line 241 of file DataListenerSvc.cpp.

00244 {
00245 
00246   ValueMap::m_type vartype;
00247   vartype = ValueMap::m_bool;
00248 
00249   MsgStream msg(msgSvc(),"DataListenerSvc");
00250 
00251   m_ValueMap.set_ptr(  static_cast <void*> (const_cast <bool*> (&var) )  );
00252   m_ValueMap.set_ptrType(vartype);
00253 
00254   Entry p1(name, m_ValueMap);
00255 
00256   m_ValNamesMap.insert(p1);
00257 
00258 }

StatusCode DataListenerSvc::finalize ( ) [virtual]

Reimplemented from Service.

Definition at line 161 of file DataListenerSvc.cpp.

00162 {
00163   MsgStream msg(msgSvc(),"DataListenerSvc");
00164 
00165   m_infoDescriptions.clear();
00166   m_ValNamesMap.clear();
00167 
00168   if (m_MonALISAMonitoring){
00169     if ( 0!= apm ) {
00170       delete apm;
00171       apm = 0 ;
00172     }
00173   }
00174 
00175   msg << MSG::DEBUG << "ApMon deleted" << endmsg;
00176   msg << MSG::INFO << "finalized successfully" << endmsg;
00177 
00178   if( m_incidentSvc ) m_incidentSvc->release();
00179 
00180   return Service::finalize();
00181 }

std::set< std::string > * DataListenerSvc::getInfos ( const IInterface * owner = 0 )

Get the names for all declared monitoring informations for a given owner.

If the owner is NULL, then it returns for all owners

Definition at line 317 of file DataListenerSvc.cpp.

00318 {
00319   std::set<std::string> * returnData = NULL;
00320   return returnData;
00321 }

void DataListenerSvc::handle ( const Incident & Inc ) [virtual]

Implementation of the IIncidentListener.h virtual method.

Definition at line 329 of file DataListenerSvc.cpp.

00331 00332 00333 00334 00335 00336 00337 00338 00339 00340 00341 00342 00343 00344 00345     } 00346 00347 00348 00349 00350     } 00351 00352 00353 00354 00355 00356     } 00357 00358 00359 00360 00361 00362     } 00363 00364 00365   } 00366 00367 }

class="fragment">00330 { MsgStream msg(msgSvc(),"DataListenerSvc"); numIncidents++; if (numIncidents % m_EventFrequency == 0){ try { Log4.open("MonitorLog.txt", std::ios::trunc); XMLLog.open(("./log" + stringConverter(fileCounter) + ".xml").c_str() , std::ios::trunc); } catch(std::exception &/*e*/) { msg << MSG::INFO << "Log File could not be opened, no monitoring available" << endmsg; if (m_MonALISAMonitoring){ // Send Data to MonALISA sendData(&m_ValNamesMap); if (m_FileMonitoring){ // Write simple text log writeMap(&m_ValNamesMap, Inc, &Log4 ); Log4.close(); if (m_XMLMonitoring){ // Write XML files writeXML(&m_ValNamesMap, Inc, &XMLLog ); XMLLog.close(); fileCounter++;

std::string DataListenerSvc::infoOwnerName ( const IInterface * owner ) [private]

Definition at line 323 of file DataListenerSvc.cpp.

00324 {
00325   std::string returnData = "";
00326   return returnData;
00327 }

StatusCode DataListenerSvc::initialize ( ) [virtual]

Reimplemented from Service.

Definition at line 75 of file DataListenerSvc.cpp.

00076 {
00077 
00078   m_ApMonSettingsFile = defaultApMonSettingsFile;
00079   StatusCode sc = Service::initialize();
00080   MsgStream msg(msgSvc(),name());
00081 
00082   jobIDString = "jobID: " + stringConverter(m_MLjobID);
00083 
00084   if ( !sc.isSuccess() )   {
00085     msg << MSG::ERROR << "Failed to initialize Service base class." << endmsg;
00086     return StatusCode::FAILURE;
00087   }
00088 
00089   sc = service("IncidentSvc", m_incidentSvc, true);
00090   if (!sc.isSuccess()) {
00091     msg << MSG::ERROR << "Failed to access incident service." << endmsg;
00092     return StatusCode::FAILURE;
00093   }
00094   m_incidentSvc->addListener(this, IncidentType::EndEvent);
00095 
00096   if (m_MonALISAMonitoring){
00097     // Initialise MonALISA
00098     apm = new ApMon(const_cast<char*>(m_ApMonSettingsFile.c_str()));
00099   }
00100 
00101   // DEBUG info on job options specified in GAUDI
00102   if (m_MLEventFrequency == defaultMLFrequency) {
00103     msg << MSG::DEBUG
00104         << "Frequency to send data to MonALISA not specified, taken as the default value: "
00105         << defaultMLFrequency << endmsg;
00106   } else {
00107     msg << MSG::INFO
00108         << "Data sent to MonALISA every "
00109         << m_MLEventFrequency << " events" << endmsg;
00110   }
00111 
00112   if (m_MLjobID == defaultjobID){
00113     msg << MSG::DEBUG
00114         << "DataListenerSvc MonALISA Job ID not specified, taken as the default value: "
00115         << defaultjobID << endmsg;
00116   }
00117 
00118   if (m_MLClusterName == defaultClusterName){
00119     msg << MSG::DEBUG
00120         << "DataListenerSvc MonALISA cluster name not specified, taken as the default value: "
00121         << defaultClusterName << endmsg;
00122   }
00123 
00124   if (m_ApMonSettingsFile == defaultApMonSettingsFile){
00125     msg << MSG::DEBUG
00126         << "MonALISA ApMon configuration file destination not specified,  will be read from: "
00127         << defaultClusterName << endmsg;
00128   }
00129 
00130   if (m_EventFrequency == defaultFrequency){
00131     msg << MSG::INFO
00132         << "XML Log file frequency not specified, taken as the default value: "
00133         << defaultFrequency << endmsg;
00134   } else {
00135     msg << MSG::INFO
00136         << "Frequency XML logs are written at: "
00137         << m_EventFrequency << endmsg;
00138   }
00139 
00140   if (m_MonALISAMonitoring) {
00141     msg << MSG::INFO
00142         << "Data will be published to a MonALISA server"
00143         << endmsg;
00144   }
00145 
00146   if (m_XMLMonitoring) {
00147     msg << MSG::INFO
00148         << "Data will be written to XML log files"
00149         << endmsg;
00150   }
00151   if (m_FileMonitoring) {
00152     msg << MSG::INFO
00153         << "Data will be updated in a Text log file"
00154         << endmsg;
00155   }
00156 
00157   return StatusCode::SUCCESS;
00158 }

std::string DataListenerSvc::resizeString	(	const std::string	text,
		const unsigned int	length
	)			`[private]`

Definition at line 370 of file DataListenerSvc.cpp.

00372 {
00373   std::string temp;
00374   unsigned int counter=0;
00375 
00376   do {
00377 
00378     if (text.length() > length) {
00379       temp = text.substr(0,(length-1));
00380     } else {
00381       if (counter==0) {
00382         temp = text;
00383         counter++;
00384       }
00385       temp.append(" ");
00386     }
00387 
00388   } while (temp.length() != length);
00389 
00390   return temp;
00391 }

void DataListenerSvc::sendData ( ValNamesMap * m_ValNamesMap ) [private]

MonALISA sender method to send Data to MonALISA server.

Definition at line 571 of file DataListenerSvc.cpp.

00572 {
00573 
00574   for (m_ValNamesMapIt = m_ValNamesMap->begin();
00575        m_ValNamesMapIt != m_ValNamesMap->end();
00576        ++m_ValNamesMapIt){
00577 
00578     m_ValueMapTemp = m_ValNamesMapIt->second;
00579     keyToSend = const_cast<char*>((m_ValNamesMapIt->first).c_str());
00580 
00581 
00582     if (m_ValueMapTemp.get_ptrType() == ValueMap::m_double){
00583       apmSend(const_cast <char*>(m_MLClusterName.c_str()),
00584               const_cast <char*> (jobIDString.c_str()),
00585               keyToSend, *(double*)m_ValueMapTemp.get_ptr());
00586     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_int){
00587       apmSend(const_cast <char*>(m_MLClusterName.c_str()),
00588               const_cast <char*> (jobIDString.c_str()),
00589               keyToSend, *(int*)m_ValueMapTemp.get_ptr());
00590     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_long){
00591       apmSend(const_cast <char*>(m_MLClusterName.c_str()),
00592               const_cast <char*> (jobIDString.c_str()),
00593               keyToSend, *(long*)m_ValueMapTemp.get_ptr());
00594     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_bool){
00595       apmSend(const_cast <char*>(m_MLClusterName.c_str()),
00596               const_cast <char*> (jobIDString.c_str()),
00597               keyToSend, *(bool*)m_ValueMapTemp.get_ptr());
00598     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_string){
00599       apmSend(const_cast <char*>(m_MLClusterName.c_str()),
00600               const_cast <char*> (jobIDString.c_str()),
00601               keyToSend, const_cast <char*>((*(std::string*)m_ValueMapTemp.get_ptr()).c_str()));
00602     }
00603   }
00604 
00605 }

std::string DataListenerSvc::stringConverter ( const long convertee ) [private]

Definition at line 414 of file DataListenerSvc.cpp.

00415 {
00416   std::stringstream s;
00417   std::string temp;
00418   s << convertee;
00419   s >> temp;
00420   s.flush();
00421   return temp;
00422 }

std::string DataListenerSvc::stringConverter ( const bool convertee ) [private]

Definition at line 424 of file DataListenerSvc.cpp.

00425 {
00426   std::stringstream s;
00427   std::string temp;
00428   s << convertee;
00429   s >> temp;
00430   s.flush();
00431   return temp;
00432 }

std::string DataListenerSvc::stringConverter ( const double convertee ) [private]

Definition at line 404 of file DataListenerSvc.cpp.

00405 {
00406   std::stringstream s;
00407   std::string temp;
00408   s << convertee;
00409   s >> temp;
00410   s.flush();
00411   return temp;
00412 }

std::string DataListenerSvc::stringConverter ( const int convertee ) [private]

Definition at line 394 of file DataListenerSvc.cpp.

00395 {
00396   std::stringstream s;
00397   std::string temp;
00398   s << convertee;
00399   s >> temp;
00400   s.flush();
00401   return temp;
00402 }

void DataListenerSvc::undeclareAll ( const IInterface * owner )

Undeclare monitoring information.

Parameters:

owner

Owner identifier of the monitoring information

Definition at line 313 of file DataListenerSvc.cpp.

00314 {
00315 }

void DataListenerSvc::undeclareInfo	(	const std::string &	name,
		const IInterface *	owner
	)

Undeclare monitoring information.

Parameters:

	name	Monitoring information name known to the external system
	owner	Owner identifier of the monitoring information

Definition at line 308 of file DataListenerSvc.cpp.

00310 {
00311 }

void DataListenerSvc::writeMap	(	ValNamesMap *	m_ValNamesMap,
		const Incident &	Inc,
		std::ofstream *	MyFile
	)			`[private]`

Definition at line 514 of file DataListenerSvc.cpp.

00516 {
00517   // prepare time ctime.h and remove trailing carriage return
00518   time ( &rawTime2 );
00519   sprintf (buffer2, "%s", ctime(&rawTime2));
00520   timeDate2 = buffer2;
00521   timeDate2.erase(timeDate2.size()-1, 1);
00522 
00523   // headings for the text file with spacing numbers
00524   std::string space = "   ";
00525   std::string heading0 = "Time                       "; // 27
00526   std::string heading1 = "No      "; // 8 chars long
00527   std::string heading2 = "Incident Type     "; // 18
00528   std::string heading3 = "Incident Source   "; // 18
00529   std::string heading4 = "Name            ";  // 16
00530   std::string heading5 = "Value               "; // 20
00531 
00532   *MyFile << heading0 + heading1 + heading2 + heading3 + heading4 + heading5
00533           << std::endl;
00534 
00535   for (m_ValNamesMapIt = m_ValNamesMap->begin();
00536        m_ValNamesMapIt != m_ValNamesMap->end();
00537        ++m_ValNamesMapIt){
00538 
00539     m_ValueMapTemp = m_ValNamesMapIt->second;
00540 
00541     *MyFile << timeDate2 << space
00542 
00543             << resizeString(stringConverter(numIncidents),8) // Counts # incidents
00544             << resizeString(Inc.type(),18)                 // Incident Type
00545             << resizeString(Inc.source(),18)               // Source of the Incident
00546             << resizeString(m_ValNamesMapIt->first,20);    // Variable Name
00547 
00548     // Check the variable type and in each case, cast accordingly
00549     if (m_ValueMapTemp.get_ptrType() == ValueMap::m_double){
00550       *MyFile << resizeString(stringConverter(*(double*)m_ValueMapTemp.get_ptr()), 12)
00551               << std::endl;
00552     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_int){
00553       *MyFile << resizeString(stringConverter(*(int*)m_ValueMapTemp.get_ptr()), 12)
00554               << std::endl;
00555     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_long){
00556       *MyFile << resizeString(stringConverter(*(long*)m_ValueMapTemp.get_ptr()), 12)
00557               << std::endl;
00558     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_bool){
00559       *MyFile << resizeString(stringConverter(*(bool*)m_ValueMapTemp.get_ptr()), 12)
00560               << std::endl;
00561     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_string){
00562       *MyFile << resizeString((*(std::string*)m_ValueMapTemp.get_ptr()), 12)
00563               << std::endl;
00564       }
00565 
00566       }
00567 
00568 }

void DataListenerSvc::writeXML	(	ValNamesMap *	m_ValNamesMap,
		const Incident &	Inc,
		std::ofstream *	MyFile
	)			`[private]`

Definition at line 435 of file DataListenerSvc.cpp.

00438 {
00439 
00440   MsgStream msg(msgSvc(),"DataListenerSvc");
00441 
00442   // prepare time ctime.h and remove trailing carriage return
00443   time ( &rawTime );
00444   sprintf (buffer, "%s", ctime(&rawTime));
00445   timeDate = buffer;
00446   timeDate.erase(timeDate.size()-1, 1);
00447 
00448 
00449   msg << MSG::INFO << "XML written to file: " << MyFile << endmsg;
00450 
00451 
00452   *MyFile << xml.declaration("1.0", "ASCII", "yes") << std::endl;
00453 
00454   *MyFile << xml.tagBegin("Results", 0, "Time", timeDate)
00455           << xml.tagBegin("Run",1);
00456 
00457 
00458   for (m_ValNamesMapIt = m_ValNamesMap->begin();
00459        m_ValNamesMapIt != m_ValNamesMap->end();
00460        ++m_ValNamesMapIt) {
00461 
00462     m_ValueMapTemp = m_ValNamesMapIt->second;
00463 
00464     *MyFile << xml.tagBegin("Incident",2);
00465 
00466     *MyFile << xml.tagBegin("IncType", 3)
00467             << xml.data(resizeString(Inc.type(),18))
00468             << xml.tagEnd("IncType", 0);
00469 
00470     *MyFile << xml.tagBegin("IncSource", 3)
00471             << xml.data(resizeString(Inc.source(),18))
00472             << xml.tagEnd("IncSource", 0);
00473 
00474     *MyFile << xml.tagBegin("VarName", 3)
00475             << xml.data(resizeString(m_ValNamesMapIt->first,20))
00476             << xml.tagEnd("VarName", 0);
00477 
00478     *MyFile << xml.tagBegin("Value", 3, "Result", stringConverter(numIncidents));
00479     // Check the variable type and in each case, cast accordingly
00480 
00481 
00482 
00483     // re-convert pointers to their original form and then to strings
00484     // so that they can be written with XMLCode.h
00485     if (m_ValueMapTemp.get_ptrType() == ValueMap::m_double){
00486       valToWrite = stringConverter(*(double*)m_ValueMapTemp.get_ptr());
00487     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_int){
00488       valToWrite = stringConverter(*(int*)m_ValueMapTemp.get_ptr());
00489     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_long){
00490       valToWrite = stringConverter(*(long*)m_ValueMapTemp.get_ptr());
00491     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_bool){
00492       valToWrite = stringConverter(*(bool*)m_ValueMapTemp.get_ptr());
00493     } else if (m_ValueMapTemp.get_ptrType() == ValueMap::m_string){
00494       valToWrite = *(std::string*)m_ValueMapTemp.get_ptr();
00495     }
00496 
00497 
00498     *MyFile << xml.data(valToWrite);
00499     msg << MSG::DEBUG << "XML written: " << m_ValNamesMapIt->first << " , "
00500         << valToWrite << endmsg;
00501 
00502     *MyFile << xml.tagEnd("Value", 0);
00503     *MyFile << xml.tagEnd("Incident",2);
00504   }
00505 
00506 
00507   *MyFile << xml.tagEnd("Run",1)
00508           << xml.tagEnd("Results", 0);
00509 
00510 }

Member Data Documentation

ApMon* DataListenerSvc::apm [private]

Definition at line 195 of file DataListenerSvc.h.

char DataListenerSvc::buffer[50] [private]

Definition at line 205 of file DataListenerSvc.h.

char DataListenerSvc::buffer2[50] [private]

Definition at line 206 of file DataListenerSvc.h.

int DataListenerSvc::FreqCriterion [private]

Definition at line 246 of file DataListenerSvc.h.

std::string DataListenerSvc::jobIDString [private]

Definition at line 265 of file DataListenerSvc.h.

char* DataListenerSvc::keyToSend [private]

Definition at line 271 of file DataListenerSvc.h.

std::ofstream DataListenerSvc::Log4 [private]

Definition at line 242 of file DataListenerSvc.h.

std::string DataListenerSvc::m_ApMonSettingsFile [private]

Definition at line 264 of file DataListenerSvc.h.

int DataListenerSvc::m_EventFrequency [private]

Definition at line 247 of file DataListenerSvc.h.

int DataListenerSvc::m_FileMonitoring [private]

Definition at line 268 of file DataListenerSvc.h.

IIncidentSvc* DataListenerSvc::m_incidentSvc [private]

Definition at line 240 of file DataListenerSvc.h.

std::map<std::string,std::string> DataListenerSvc::m_infoDescriptions [private]

Definition at line 257 of file DataListenerSvc.h.

InfoNamesMap DataListenerSvc::m_InfoNamesMap [private]

Definition at line 230 of file DataListenerSvc.h.

InfoNamesMap::iterator DataListenerSvc::m_InfoNamesMapIt [private]

Definition at line 231 of file DataListenerSvc.h.

std::string DataListenerSvc::m_MLClusterName [private]

Definition at line 263 of file DataListenerSvc.h.

int DataListenerSvc::m_MLEventFrequency [private]

Definition at line 262 of file DataListenerSvc.h.

int DataListenerSvc::m_MLjobID [private]

Definition at line 261 of file DataListenerSvc.h.

int DataListenerSvc::m_MonALISAMonitoring [private]

Definition at line 266 of file DataListenerSvc.h.

ValNamesMap DataListenerSvc::m_ValNamesMap [private]

Definition at line 233 of file DataListenerSvc.h.

ValNamesMap::iterator DataListenerSvc::m_ValNamesMapIt [private]

Definition at line 234 of file DataListenerSvc.h.

ValueMap DataListenerSvc::m_ValueMap [private]

Definition at line 199 of file DataListenerSvc.h.

ValueMap DataListenerSvc::m_ValueMapTemp [private]

Definition at line 200 of file DataListenerSvc.h.

int DataListenerSvc::m_XMLMonitoring [private]

Definition at line 267 of file DataListenerSvc.h.

FILE* DataListenerSvc::MonitorLog [private]

Definition at line 241 of file DataListenerSvc.h.

time_t DataListenerSvc::rawTime [private]

Definition at line 202 of file DataListenerSvc.h.

time_t DataListenerSvc::rawTime2 [private]

Definition at line 203 of file DataListenerSvc.h.

std::string DataListenerSvc::timeDate [private]

Definition at line 207 of file DataListenerSvc.h.

std::string DataListenerSvc::timeDate2 [private]

Definition at line 208 of file DataListenerSvc.h.

std::string DataListenerSvc::valToWrite [private]

Definition at line 209 of file DataListenerSvc.h.

XmlCode DataListenerSvc::xml [private]

Definition at line 235 of file DataListenerSvc.h.

std::ofstream DataListenerSvc::XMLLog [private]

Definition at line 243 of file DataListenerSvc.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r0/GaudiMonitor/src/DataListenerSvc/DataListenerSvc.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r0/GaudiMonitor/src/DataListenerSvc/DataListenerSvc.cpp

Gaudi Framework, version v22r0

DataListenerSvc Class Reference

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation