CMS 3D CMS Logo

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Types | Private Member Functions | Private Attributes
stor::SMWebPageHelper Class Reference

#include <SMWebPageHelper.h>

Inheritance diagram for stor::SMWebPageHelper:
stor::WebPageHelper< SMWebPageHelper >

Public Member Functions

void consumerStatistics (xgi::Output *) const
 
void defaultWebPage (xgi::Output *) const
 
void dqmEventWebPage (xgi::Output *) const
 
void filesWebPage (xgi::Output *) const
 
void resourceBrokerDetail (xgi::Output *, const long long &uniqueRBID) const
 
void resourceBrokerOverview (xgi::Output *) const
 
 SMWebPageHelper (xdaq::ApplicationDescriptor *, SharedResourcesPtr)
 
void storedDataWebPage (xgi::Output *) const
 
void throughputWebPage (xgi::Output *) const
 
- Public Member Functions inherited from stor::WebPageHelper< SMWebPageHelper >
void css (xgi::Input *in, xgi::Output *out)
 
 WebPageHelper (xdaq::ApplicationDescriptor *, const std::string &cvsVersion, SMWebPageHelper *callee, void(SMWebPageHelper::*addHyperLinks)(XHTMLMaker &, XHTMLMaker::Node *) const )
 

Private Types

typedef ConsumerWebPageHelper
< SMWebPageHelper,
EventQueueCollection,
StatisticsReporter
ConsumerWebPageHelper_t
 

Private Member Functions

void addDOMforConfigString (XHTMLMaker &maker, XHTMLMaker::Node *parent, DiskWritingParams const &) const
 
void addDOMforFiles (XHTMLMaker &maker, XHTMLMaker::Node *parent, FilesMonitorCollection const &) const
 
void addDOMforFragmentMonitor (XHTMLMaker &maker, XHTMLMaker::Node *parent, FragmentMonitorCollection const &) const
 
void addDOMforHyperLinks (XHTMLMaker &, XHTMLMaker::Node *parent) const
 
void addDOMforResourceUsage (XHTMLMaker &, XHTMLMaker::Node *parent, ResourceMonitorCollection const &, ThroughputMonitorCollection const &) const
 
void addDOMforRunMonitor (XHTMLMaker &maker, XHTMLMaker::Node *parent, RunMonitorCollection const &) const
 
void addDOMforStoredData (XHTMLMaker &maker, XHTMLMaker::Node *parent, StreamsMonitorCollection const &) const
 
void addDOMforThroughputStatistics (XHTMLMaker &maker, XHTMLMaker::Node *parent, ThroughputMonitorCollection const &) const
 
void addFilterUnitList (XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
 
void addFragmentStats (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addOutputModuleStatistics (XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
 
void addOutputModuleStatistics (XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection::OutputModuleResultsList const &) const
 
void addOutputModuleSummary (XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection::OutputModuleResultsList const &) const
 
void addOutputModuleTables (XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection const &) const
 
void addResourceBrokerDetails (XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
 
void addResourceBrokerList (XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection const &) const
 
void addRowForBandwidth (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForFramesReceived (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForLatency (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForMaxBandwidth (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForMinBandwidth (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForRate (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForThroughputStatistics (XHTMLMaker &maker, XHTMLMaker::Node *table, const ThroughputMonitorCollection::Stats::Snapshot &, bool const isAverage=false) const
 
void addRowForTotalVolume (XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowsForMemoryUsage (XHTMLMaker &maker, XHTMLMaker::Node *table, MonitoredQuantity::Stats const &) const
 
void addRowsForSataBeast (XHTMLMaker &maker, XHTMLMaker::Node *table, ResourceMonitorCollection::Stats const &) const
 
void addRowsForWorkers (XHTMLMaker &maker, XHTMLMaker::Node *table, ResourceMonitorCollection::Stats const &) const
 
void addTableForDiskUsages (XHTMLMaker &maker, XHTMLMaker::Node *parent, ResourceMonitorCollection::Stats const &) const
 
void addTableForResourceUsages (XHTMLMaker &maker, XHTMLMaker::Node *parent, ResourceMonitorCollection::Stats const &, MonitoredQuantity::Stats const &) const
 
XHTMLMaker::NodecreateWebPageBody (XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
 
void listStreamRecordsStats (XHTMLMaker &maker, XHTMLMaker::Node *table, StreamsMonitorCollection const &, const MonitoredQuantity::DataSetType) const
 
SMWebPageHelperoperator= (SMWebPageHelper const &)
 
 SMWebPageHelper (SMWebPageHelper const &)
 

Private Attributes

ConsumerWebPageHelper_t consumerWebPageHelper_
 
SharedResourcesPtr sharedResources_
 

Additional Inherited Members

- Protected Member Functions inherited from stor::WebPageHelper< SMWebPageHelper >
void addDOMforDQMEventStatistics (XHTMLMaker &maker, XHTMLMaker::Node *parent, DQMEventMonitorCollection const &) const
 
void addDOMforHyperLinks (XHTMLMaker &maker, XHTMLMaker::Node *parent) const
 
void addDOMforProcessedDQMEvents (XHTMLMaker &maker, XHTMLMaker::Node *parent, DQMEventMonitorCollection const &) const
 
void addDQMEventStats (XHTMLMaker &maker, XHTMLMaker::Node *table, DQMEventMonitorCollection::DQMEventStats const &, const MonitoredQuantity::DataSetType) const
 
void addDurationToTableHead (XHTMLMaker &maker, XHTMLMaker::Node *tableRow, const utils::Duration_t) const
 
void addRowForDQMEventBandwidth (XHTMLMaker &maker, XHTMLMaker::Node *table, DQMEventMonitorCollection::DQMEventStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForDQMEventsProcessed (XHTMLMaker &maker, XHTMLMaker::Node *table, DQMEventMonitorCollection::DQMEventStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForMaxDQMEventBandwidth (XHTMLMaker &maker, XHTMLMaker::Node *table, DQMEventMonitorCollection::DQMEventStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForMinDQMEventBandwidth (XHTMLMaker &maker, XHTMLMaker::Node *table, DQMEventMonitorCollection::DQMEventStats const &, const MonitoredQuantity::DataSetType) const
 
void addRowForTotalDQMEventVolume (XHTMLMaker &maker, XHTMLMaker::Node *table, DQMEventMonitorCollection::DQMEventStats const &, const MonitoredQuantity::DataSetType) const
 
std::string baseURL () const
 
XHTMLMaker::NodecreateWebPageBody (XHTMLMaker &, const std::string &pageTitle, const std::string &externallyVisibleState, const std::string &innerStateName, const std::string &errorMsg) const
 
- Protected Attributes inherited from stor::WebPageHelper< SMWebPageHelper >
std::map< unsigned int,
std::string > 
alarmColors_
 
xdaq::ApplicationDescriptor * appDescriptor_
 
XHTMLMaker::AttrMap rowAttr_
 
XHTMLMaker::AttrMap specialRowAttr_
 
XHTMLMaker::AttrMap tableAttr_
 
XHTMLMaker::AttrMap tableLabelAttr_
 
XHTMLMaker::AttrMap tableValueAttr_
 

Detailed Description

Helper class to handle web page requests

Author:
mommsen
Revision:
1.1.4.2
Date:
2011/03/07 11:33:04

Definition at line 43 of file SMWebPageHelper.h.

Member Typedef Documentation

Definition at line 431 of file SMWebPageHelper.h.

Constructor & Destructor Documentation

stor::SMWebPageHelper::SMWebPageHelper ( xdaq::ApplicationDescriptor *  appDesc,
SharedResourcesPtr  sharedResources 
)

Definition at line 38 of file SMWebPageHelper.cc.

41  :
42  WebPageHelper<SMWebPageHelper>(appDesc, "$Name: $", this, &stor::SMWebPageHelper::addDOMforHyperLinks),
43  sharedResources_(sharedResources),
45  {}
ConsumerWebPageHelper_t consumerWebPageHelper_
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
SharedResourcesPtr sharedResources_
stor::SMWebPageHelper::SMWebPageHelper ( SMWebPageHelper const &  )
private

Member Function Documentation

void stor::SMWebPageHelper::addDOMforConfigString ( XHTMLMaker maker,
XHTMLMaker::Node parent,
DiskWritingParams const &  dwParams 
) const
private

Adds the SM config string to the parent DOM element

Definition at line 901 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), and stor::DiskWritingParams::streamConfiguration_.

Referenced by storedDataWebPage().

906  {
907  XHTMLMaker::Node* table = maker.addNode("table", parent);
908  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, specialRowAttr_);
909  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow);
910  maker.addText(tableDiv, "SM Configuration");
911  tableRow = maker.addNode("tr", table, rowAttr_);
912  tableDiv = maker.addNode("td", tableRow);
913  XHTMLMaker::AttrMap textareaAttr;
914  textareaAttr[ "rows" ] = "10";
915  textareaAttr[ "cols" ] = "100";
916  textareaAttr[ "scroll" ] = "yes";
917  textareaAttr[ "readonly" ];
918  textareaAttr[ "title" ] = "SM config";
919  XHTMLMaker::Node* textarea = maker.addNode("textarea", tableDiv, textareaAttr);
920  maker.addText(textarea, dwParams.streamConfiguration_);
921  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addDOMforFiles ( XHTMLMaker maker,
XHTMLMaker::Node parent,
FilesMonitorCollection const &  fmc 
) const
private

Adds files statistics to the parent DOM element

Definition at line 1005 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addHex(), stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), and stor::FilesMonitorCollection::getFileRecords().

Referenced by filesWebPage().

1010  {
1012  fmc.getFileRecords(fileRecords);
1013 
1014  XHTMLMaker::AttrMap colspanAttr;
1015  colspanAttr[ "colspan" ] = "6";
1016 
1017  XHTMLMaker::AttrMap tableLabelAttr = tableLabelAttr_;
1018  tableLabelAttr[ "align" ] = "center";
1019 
1020  XHTMLMaker::AttrMap tableValueWidthAttr;
1021  tableValueWidthAttr[ "width" ] = "11%";
1022 
1023  XHTMLMaker::AttrMap tableCounterWidthAttr;
1024  tableCounterWidthAttr[ "width" ] = "5%";
1025 
1026  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1027 
1028  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1029  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1030  maker.addText(tableDiv, "File Statistics (most recent first)");
1031 
1032  // Header
1033  tableRow = maker.addNode("tr", table, specialRowAttr_);
1034  tableDiv = maker.addNode("th", tableRow, tableCounterWidthAttr);
1035  maker.addText(tableDiv, "#");
1036  tableDiv = maker.addNode("th", tableRow);
1037  maker.addText(tableDiv, "Pathname");
1038  tableDiv = maker.addNode("th", tableRow, tableValueWidthAttr);
1039  maker.addText(tableDiv, "Events");
1040  tableDiv = maker.addNode("th", tableRow, tableValueWidthAttr);
1041  maker.addText(tableDiv, "Size (Bytes)");
1042  tableDiv = maker.addNode("th", tableRow, tableValueWidthAttr);
1043  maker.addText(tableDiv, "Closing reason");
1044  tableDiv = maker.addNode("th", tableRow, tableValueWidthAttr);
1045  maker.addText(tableDiv, "Adler32");
1046 
1047  // File list
1048  if (fileRecords.empty())
1049  {
1050  tableRow = maker.addNode("tr", table, rowAttr_);
1051  tableDiv = maker.addNode("td", tableRow, colspanAttr);
1052  maker.addText(tableDiv, "no files available yet");
1053  return;
1054  }
1055 
1056  for (
1057  FilesMonitorCollection::FileRecordList::const_reverse_iterator
1058  it = fileRecords.rbegin(), itEnd = fileRecords.rend();
1059  it != itEnd;
1060  ++it
1061  )
1062  {
1063  tableRow = maker.addNode("tr", table, rowAttr_);
1064  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1065  maker.addInt( tableDiv, (*it)->entryCounter );
1066  tableDiv = maker.addNode("td", tableRow);
1067  maker.addText(tableDiv, (*it)->completeFileName());
1068  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1069  maker.addInt( tableDiv, (*it)->eventCount );
1070  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1071  maker.addInt( tableDiv, (*it)->fileSize );
1072  tableDiv = maker.addNode("td", tableRow, tableLabelAttr);
1073  maker.addText(tableDiv, (*it)->closingReason());
1074  tableDiv = maker.addNode("td", tableRow, tableLabelAttr);
1075  maker.addHex(tableDiv, (*it)->adler32);
1076  }
1077  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
boost::circular_buffer< FileRecordPtr > FileRecordList
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
cc *****************************************************cc the common blocks pinput and cwdidth are for input parameters cc these parameters needed to be interfaced to other program common pinput fmc
Definition: inclcon.h:4
void stor::SMWebPageHelper::addDOMforFragmentMonitor ( XHTMLMaker maker,
XHTMLMaker::Node parent,
FragmentMonitorCollection const &  fmc 
) const
private

Adds fragment monitoring statistics to the parent DOM element

Definition at line 521 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::MonitoredQuantity::FULL, stor::FragmentMonitorCollection::getStats(), and stor::MonitoredQuantity::RECENT.

Referenced by defaultWebPage().

526  {
527  FragmentMonitorCollection::FragmentStats stats;
528  fmc.getStats(stats);
529 
530  XHTMLMaker::AttrMap colspanAttr;
531  colspanAttr[ "colspan" ] = "4";
532 
533  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
534 
535  // Received Data Statistics header
536  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
537  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
538  maker.addText(tableDiv, "Received I2O Frames");
539 
540  // Parameter/Value header
541  tableRow = maker.addNode("tr", table, rowAttr_);
542  tableDiv = maker.addNode("th", tableRow);
543  maker.addText(tableDiv, "Parameter");
544  tableDiv = maker.addNode("th", tableRow);
545  maker.addText(tableDiv, "Total");
546  tableDiv = maker.addNode("th", tableRow);
547  maker.addText(tableDiv, "Events");
548  tableDiv = maker.addNode("th", tableRow);
549  maker.addText(tableDiv, "DQM histos");
550 
552 
554  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
void addFragmentStats(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
cc *****************************************************cc the common blocks pinput and cwdidth are for input parameters cc these parameters needed to be interfaced to other program common pinput fmc
Definition: inclcon.h:4
void stor::SMWebPageHelper::addDOMforHyperLinks ( XHTMLMaker maker,
XHTMLMaker::Node parent 
) const
private

Adds the links for the other hyperdaq webpages

Definition at line 263 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), and link().

Referenced by defaultWebPage(), dqmEventWebPage(), filesWebPage(), resourceBrokerOverview(), storedDataWebPage(), and throughputWebPage().

267  {
268  std::string url = appDescriptor_->getContextDescriptor()->getURL()
269  + "/" + appDescriptor_->getURN();
270 
271  XHTMLMaker::AttrMap linkAttr;
273 
274  maker.addNode("hr", parent);
275 
276  linkAttr[ "href" ] = url;
277  link = maker.addNode("a", parent, linkAttr);
278  maker.addText(link, "Main web page");
279 
280  maker.addNode("hr", parent);
281 
282  linkAttr[ "href" ] = url + "/storedData";
283  link = maker.addNode("a", parent, linkAttr);
284  maker.addText(link, "Stored data web page");
285 
286  maker.addNode("hr", parent);
287 
288  linkAttr[ "href" ] = url + "/rbsenderlist";
289  link = maker.addNode("a", parent, linkAttr);
290  maker.addText(link, "RB Sender list web page");
291 
292  maker.addNode("hr", parent);
293 
294  linkAttr[ "href" ] = url + "/fileStatistics";
295  link = maker.addNode("a", parent, linkAttr);
296  maker.addText(link, "File Statistics web page");
297 
298  maker.addNode("hr", parent);
299 
300  linkAttr[ "href" ] = url + "/consumerStatistics";
301  link = maker.addNode("a", parent, linkAttr);
302  maker.addText(link, "Consumer Statistics");
303 
304  maker.addNode("hr", parent);
305 
306  linkAttr[ "href" ] = url + "/dqmEventStatistics";
307  link = maker.addNode("a", parent, linkAttr);
308  maker.addText(link, "DQM event processor statistics");
309 
310  maker.addNode("hr", parent);
311 
312  linkAttr[ "href" ] = url + "/throughputStatistics";
313  link = maker.addNode("a", parent, linkAttr);
314  maker.addText(link, "Throughput statistics");
315 
316  maker.addNode("hr", parent);
317  }
xdaq::ApplicationDescriptor * appDescriptor_
list parent
Definition: dbtoconf.py:74
std::string link(std::string &nm, std::string &ns)
Definition: hierarchy.cc:47
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addDOMforResourceUsage ( XHTMLMaker maker,
XHTMLMaker::Node parent,
ResourceMonitorCollection const &  rmc,
ThroughputMonitorCollection const &  tmc 
) const
private

Adds the resource table to the parent DOM element

Definition at line 321 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::ThroughputMonitorCollection::getPoolUsageMQ(), stor::ResourceMonitorCollection::getStats(), stor::MonitoredQuantity::getStats(), and asciidump::table.

Referenced by defaultWebPage().

327  {
328  ResourceMonitorCollection::Stats rmcStats;
329  rmc.getStats(rmcStats);
330  MonitoredQuantity::Stats poolUsageStats;
331  tmc.getPoolUsageMQ().getStats(poolUsageStats);
332 
333  XHTMLMaker::AttrMap halfWidthAttr;
334  halfWidthAttr[ "width" ] = "50%";
335 
336  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
337 
338  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
339 
340  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow, halfWidthAttr);
341  addTableForResourceUsages(maker, tableDiv, rmcStats, poolUsageStats);
342 
343  tableDiv = maker.addNode("td", tableRow, halfWidthAttr);
344  addTableForDiskUsages(maker, tableDiv, rmcStats);
345  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
void addTableForResourceUsages(XHTMLMaker &maker, XHTMLMaker::Node *parent, ResourceMonitorCollection::Stats const &, MonitoredQuantity::Stats const &) const
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
void addTableForDiskUsages(XHTMLMaker &maker, XHTMLMaker::Node *parent, ResourceMonitorCollection::Stats const &) const
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addDOMforRunMonitor ( XHTMLMaker maker,
XHTMLMaker::Node parent,
RunMonitorCollection const &  rmc 
) const
private

Adds run monitoring statistics to the parent DOM element

Definition at line 736 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::RunMonitorCollection::getEoLSSeenMQ(), stor::RunMonitorCollection::getErrorEventIDsReceivedMQ(), stor::RunMonitorCollection::getEventIDsReceivedMQ(), stor::MonitoredQuantity::Stats::getLastSampleValue(), stor::RunMonitorCollection::getLumiSectionsSeenMQ(), stor::RunMonitorCollection::getRunNumbersSeenMQ(), stor::MonitoredQuantity::Stats::getSampleCount(), stor::MonitoredQuantity::getStats(), and stor::RunMonitorCollection::getUnwantedEventIDsReceivedMQ().

Referenced by defaultWebPage().

741  {
742  MonitoredQuantity::Stats eventIDsReceivedStats;
743  rmc.getEventIDsReceivedMQ().getStats(eventIDsReceivedStats);
744  MonitoredQuantity::Stats errorEventIDsReceivedStats;
745  rmc.getErrorEventIDsReceivedMQ().getStats(errorEventIDsReceivedStats);
746  MonitoredQuantity::Stats unwantedEventIDsReceivedStats;
747  rmc.getUnwantedEventIDsReceivedMQ().getStats(unwantedEventIDsReceivedStats);
748  MonitoredQuantity::Stats runNumbersSeenStats;
749  rmc.getRunNumbersSeenMQ().getStats(runNumbersSeenStats);
750  MonitoredQuantity::Stats lumiSectionsSeenStats;
751  rmc.getLumiSectionsSeenMQ().getStats(lumiSectionsSeenStats);
752  MonitoredQuantity::Stats eolsSeenStats;
753  rmc.getEoLSSeenMQ().getStats(eolsSeenStats);
754 
755  XHTMLMaker::AttrMap colspanAttr;
756  colspanAttr[ "colspan" ] = "6";
757 
758  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
759  tableValueAttr[ "width" ] = "16%";
760 
761  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
762 
763  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
764  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
765  maker.addText(tableDiv, "Storage Manager Statistics");
766 
767  // Run number and lumi section
768  tableRow = maker.addNode("tr", table, rowAttr_);
769  tableDiv = maker.addNode("td", tableRow);
770  maker.addText(tableDiv, "Run number");
771  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
772  maker.addDouble( tableDiv, runNumbersSeenStats.getLastSampleValue(), 0 );
773  tableDiv = maker.addNode("td", tableRow);
774  maker.addText(tableDiv, "Current lumi section");
775  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
776  maker.addDouble( tableDiv, lumiSectionsSeenStats.getLastSampleValue(), 0 );
777  tableDiv = maker.addNode("td", tableRow);
778  maker.addText(tableDiv, "Last EoLS");
779  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
780  maker.addDouble( tableDiv, eolsSeenStats.getLastSampleValue(), 0 );
781 
782  // Total events received
783  tableRow = maker.addNode("tr", table, specialRowAttr_);
784  tableDiv = maker.addNode("td", tableRow);
785  maker.addText(tableDiv, "Events received (non-unique)");
786  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
787  maker.addInt( tableDiv, eventIDsReceivedStats.getSampleCount() );
788  tableDiv = maker.addNode("td", tableRow);
789  maker.addText(tableDiv, "Error events received");
790  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
791  maker.addInt( tableDiv, errorEventIDsReceivedStats.getSampleCount() );
792  tableDiv = maker.addNode("td", tableRow);
793  maker.addText(tableDiv, "Unwanted events received");
794  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
795  maker.addInt( tableDiv, unwantedEventIDsReceivedStats.getSampleCount() );
796 
797  // Last event IDs
798  tableRow = maker.addNode("tr", table, rowAttr_);
799  tableDiv = maker.addNode("td", tableRow);
800  maker.addText(tableDiv, "Last event ID");
801  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
802  maker.addDouble( tableDiv, eventIDsReceivedStats.getLastSampleValue(), 0 );
803  tableDiv = maker.addNode("td", tableRow);
804  maker.addText(tableDiv, "Last error event ID");
805  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
806  maker.addDouble( tableDiv, errorEventIDsReceivedStats.getLastSampleValue(), 0 );
807  tableDiv = maker.addNode("td", tableRow);
808  maker.addText(tableDiv, "Last unwanted event ID");
809  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
810  maker.addDouble( tableDiv, unwantedEventIDsReceivedStats.getLastSampleValue(), 0 );
811  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addDOMforStoredData ( XHTMLMaker maker,
XHTMLMaker::Node parent,
StreamsMonitorCollection const &  smc 
) const
private

Adds stored data statistics to the parent DOM element

Definition at line 815 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::MonitoredQuantity::FULL, stor::StreamsMonitorCollection::getAllStreamsVolumeMQ(), stor::MonitoredQuantity::Stats::getDuration(), stor::MonitoredQuantity::getStats(), stor::MonitoredQuantity::RECENT, and stor::StreamsMonitorCollection::streamRecordsExist().

Referenced by storedDataWebPage().

820  {
821  MonitoredQuantity::Stats allStreamsVolumeStats;
822  smc.getAllStreamsVolumeMQ().getStats(allStreamsVolumeStats);
823 
824  XHTMLMaker::AttrMap tableValueWidthAttr;
825  tableValueWidthAttr[ "width" ] = "11%";
826 
827  XHTMLMaker::AttrMap rowspanAttr = tableValueWidthAttr;
828  rowspanAttr[ "rowspan" ] = "2";
829  rowspanAttr[ "valign" ] = "top";
830 
831  XHTMLMaker::AttrMap colspanAttr;
832  colspanAttr[ "colspan" ] = "9";
833 
834  XHTMLMaker::AttrMap bandwidthColspanAttr;
835  bandwidthColspanAttr[ "colspan" ] = "4";
836 
837  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
838 
839  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
840  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
841  maker.addText(tableDiv, "Stored Data Statistics");
842 
843  // Header
844  tableRow = maker.addNode("tr", table, specialRowAttr_);
845  tableDiv = maker.addNode("th", tableRow, rowspanAttr);
846  maker.addText(tableDiv, "Stream");
847  tableDiv = maker.addNode("th", tableRow, rowspanAttr);
848  maker.addText(tableDiv, "Fraction to disk");
849  tableDiv = maker.addNode("th", tableRow, rowspanAttr);
850  maker.addText(tableDiv, "Files");
851  tableDiv = maker.addNode("th", tableRow, rowspanAttr);
852  maker.addText(tableDiv, "Events");
853  tableDiv = maker.addNode("th", tableRow, rowspanAttr);
854  maker.addText(tableDiv, "Events/s");
855  tableDiv = maker.addNode("th", tableRow, rowspanAttr);
856  maker.addText(tableDiv, "Volume (MB)");
857  tableDiv = maker.addNode("th", tableRow, bandwidthColspanAttr);
858  maker.addText(tableDiv, "Bandwidth (MB/s)");
859 
860  tableRow = maker.addNode("tr", table, specialRowAttr_);
861  tableDiv = maker.addNode("th", tableRow, tableValueWidthAttr);
862  maker.addText(tableDiv, "average");
863  tableDiv = maker.addNode("th", tableRow, tableValueWidthAttr);
864  maker.addText(tableDiv, "min");
865  tableDiv = maker.addNode("th", tableRow, tableValueWidthAttr);
866  maker.addText(tableDiv, "max");
867 
868  if (! smc.streamRecordsExist())
869  {
870  tableRow = maker.addNode("tr", table, rowAttr_);
871  tableDiv = maker.addNode("td", tableRow, colspanAttr);
872  maker.addText(tableDiv, "no streams available yet");
873  return;
874  }
875  // Mean performance
876  tableRow = maker.addNode("tr", table, rowAttr_);
877  tableDiv = maker.addNode("th", tableRow, colspanAttr);
878  {
879  std::ostringstream tmpString;
880  tmpString << "Mean performance for " <<
881  allStreamsVolumeStats.getDuration().total_seconds() << " s";
882  maker.addText(tableDiv, tmpString.str());
883  }
885 
886 
887  // Recent performance
888  tableRow = maker.addNode("tr", table, rowAttr_);
889  tableDiv = maker.addNode("th", tableRow, colspanAttr);
890  {
891  std::ostringstream tmpString;
892  tmpString << "Recent performance for the last " <<
893  allStreamsVolumeStats.getDuration(MonitoredQuantity::RECENT).total_seconds() << " s";
894  maker.addText(tableDiv, tmpString.str());
895  }
897  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
void listStreamRecordsStats(XHTMLMaker &maker, XHTMLMaker::Node *table, StreamsMonitorCollection const &, const MonitoredQuantity::DataSetType) const
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addDOMforThroughputStatistics ( XHTMLMaker maker,
XHTMLMaker::Node parent,
ThroughputMonitorCollection const &  tmc 
) const
private

Adds throughput statistics to the parent DOM element

Definition at line 1081 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::ThroughputMonitorCollection::Stats::average, stor::ThroughputMonitorCollection::getStats(), and stor::ThroughputMonitorCollection::Stats::snapshots.

Referenced by throughputWebPage().

1086  {
1087  XHTMLMaker::AttrMap colspanAttr;
1088  colspanAttr[ "colspan" ] = "21";
1089 
1090  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1091 
1092  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1093  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1094  maker.addText(tableDiv, "Throughput Statistics");
1095 
1096  // Header
1097  tableRow = maker.addNode("tr", table, specialRowAttr_);
1098  tableDiv = maker.addNode("th", tableRow);
1099  maker.addText(tableDiv, "Time (UTC)");
1100  tableDiv = maker.addNode("th", tableRow);
1101  maker.addText(tableDiv, "Memory pool usage (bytes)");
1102  tableDiv = maker.addNode("th", tableRow);
1103  maker.addText(tableDiv, "Instantaneous Number of Fragments in Fragment Queue");
1104  tableDiv = maker.addNode("th", tableRow);
1105  maker.addText(tableDiv, "Memory used in Fragment Queue (MB)");
1106  tableDiv = maker.addNode("th", tableRow);
1107  maker.addText(tableDiv, "Number of Fragments Popped from Fragment Queue (Hz)");
1108  tableDiv = maker.addNode("th", tableRow);
1109  maker.addText(tableDiv, "Data Rate Popped from Fragment Queue (MB/sec)");
1110  tableDiv = maker.addNode("th", tableRow);
1111  maker.addText(tableDiv, "Fragment Processor Thread Busy Percentage");
1112  tableDiv = maker.addNode("th", tableRow);
1113  maker.addText(tableDiv, "Instantaneous Number of Events in Fragment Store");
1114  tableDiv = maker.addNode("th", tableRow);
1115  maker.addText(tableDiv, "Memory used in Fragment Store (MB)");
1116  tableDiv = maker.addNode("th", tableRow);
1117  maker.addText(tableDiv, "Instantaneous Number of Events in Stream Queue");
1118  tableDiv = maker.addNode("th", tableRow);
1119  maker.addText(tableDiv, "Memory used in Stream Queue (MB)");
1120  tableDiv = maker.addNode("th", tableRow);
1121  maker.addText(tableDiv, "Number of Events Popped from Stream Queue (Hz)");
1122  tableDiv = maker.addNode("th", tableRow);
1123  maker.addText(tableDiv, "Data Rate Popped from Stream Queue (MB/sec)");
1124  tableDiv = maker.addNode("th", tableRow);
1125  maker.addText(tableDiv, "Disk Writer Thread Busy Percentage");
1126  tableDiv = maker.addNode("th", tableRow);
1127  maker.addText(tableDiv, "Number of Events Written to Disk (Hz)");
1128  tableDiv = maker.addNode("th", tableRow);
1129  maker.addText(tableDiv, "Data Rate to Disk (MB/sec)");
1130  tableDiv = maker.addNode("th", tableRow);
1131  maker.addText(tableDiv, "Instantaneous Number of DQMEvents in DQMEvent Queue");
1132  tableDiv = maker.addNode("th", tableRow);
1133  maker.addText(tableDiv, "Memory used in DQMEvent Queue (MB)");
1134  tableDiv = maker.addNode("th", tableRow);
1135  maker.addText(tableDiv, "Number of DQMEvents Popped from DQMEvent Queue (Hz)");
1136  tableDiv = maker.addNode("th", tableRow);
1137  maker.addText(tableDiv, "Data Rate Popped from DQMEvent Queue (MB/sec)");
1138  tableDiv = maker.addNode("th", tableRow);
1139  maker.addText(tableDiv, "DQMEvent Processor Thread Busy Percentage");
1140 
1141  ThroughputMonitorCollection::Stats stats;
1142  tmc.getStats(stats);
1143 
1144  addRowForThroughputStatistics(maker, table, stats.average, true);
1145 
1146  for (ThroughputMonitorCollection::Stats::Snapshots::const_iterator
1147  it = stats.snapshots.begin(),
1148  itEnd = stats.snapshots.end();
1149  it != itEnd;
1150  ++it)
1151  {
1152  addRowForThroughputStatistics(maker, table, (*it));
1153  }
1154 
1155  addRowForThroughputStatistics(maker, table, stats.average, true);
1156  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
void addRowForThroughputStatistics(XHTMLMaker &maker, XHTMLMaker::Node *table, const ThroughputMonitorCollection::Stats::Snapshot &, bool const isAverage=false) const
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addFilterUnitList ( XHTMLMaker maker,
XHTMLMaker::Node parent,
long long  uniqueRBID,
DataSenderMonitorCollection const &  dsmc 
) const
private

Adds information about the filter units for a specific resource broker to the parent DOM element

Definition at line 1738 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::DataSenderMonitorCollection::getFilterUnitResultsForRB(), combine::key, and stor::MonitoredQuantity::RECENT.

1744  {
1746  dsmc.getFilterUnitResultsForRB(uniqueRBID);
1747 
1748  XHTMLMaker::AttrMap colspanAttr;
1749  colspanAttr[ "colspan" ] = "13";
1750 
1751  XHTMLMaker::AttrMap tableSuspiciousValueAttr = tableValueAttr_;
1752  tableSuspiciousValueAttr[ "style" ] = "background-color: yellow;";
1753 
1754  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1755 
1756  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1757  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1758  maker.addText(tableDiv, "Filter Units");
1759 
1760  // Header
1761  tableRow = maker.addNode("tr", table, specialRowAttr_);
1762  tableDiv = maker.addNode("th", tableRow);
1763  maker.addText(tableDiv, "Process ID");
1764  tableDiv = maker.addNode("th", tableRow);
1765  maker.addText(tableDiv, "# of INIT messages");
1766  tableDiv = maker.addNode("th", tableRow);
1767  maker.addText(tableDiv, "# of events");
1768  tableDiv = maker.addNode("th", tableRow);
1769  maker.addText(tableDiv, "# of error events");
1770  tableDiv = maker.addNode("th", tableRow);
1771  maker.addText(tableDiv, "# of faulty events");
1772  tableDiv = maker.addNode("th", tableRow);
1773  maker.addText(tableDiv, "# of outstanding data discards");
1774  tableDiv = maker.addNode("th", tableRow);
1775  maker.addText(tableDiv, "# of DQM events");
1776  tableDiv = maker.addNode("th", tableRow);
1777  maker.addText(tableDiv, "# of faulty DQM events");
1778  tableDiv = maker.addNode("th", tableRow);
1779  maker.addText(tableDiv, "# of outstanding DQM discards");
1780  tableDiv = maker.addNode("th", tableRow);
1781  maker.addText(tableDiv, "# of ignored discards");
1782  tableDiv = maker.addNode("th", tableRow);
1783  maker.addText(tableDiv, "Recent event rate (Hz)");
1784  tableDiv = maker.addNode("th", tableRow);
1785  maker.addText(tableDiv, "Last event number received");
1786  tableDiv = maker.addNode("th", tableRow);
1787  maker.addText(tableDiv, "Last run number received");
1788 
1789  if (fuResultsList.empty())
1790  {
1791  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1792  messageAttr[ "align" ] = "center";
1793 
1794  tableRow = maker.addNode("tr", table, rowAttr_);
1795  tableDiv = maker.addNode("td", tableRow, messageAttr);
1796  maker.addText(tableDiv, "No filter units have registered yet.");
1797  return;
1798  }
1799  else
1800  {
1801  for (unsigned int idx = 0; idx < fuResultsList.size(); ++idx)
1802  {
1803  tableRow = maker.addNode("tr", table, rowAttr_);
1804 
1805  tableDiv = maker.addNode("td", tableRow);
1806  maker.addInt( tableDiv, fuResultsList[idx]->key.fuProcessId );
1807  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1808  maker.addInt( tableDiv, fuResultsList[idx]->initMsgCount );
1809  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1810  maker.addInt( tableDiv, fuResultsList[idx]->shortIntervalEventStats.getSampleCount() );
1811  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1812  maker.addInt( tableDiv, fuResultsList[idx]->errorEventStats.getSampleCount() );
1813 
1814  if (fuResultsList[idx]->faultyEventStats.getSampleCount() != 0)
1815  {
1816  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1817  }
1818  else
1819  {
1820  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1821  }
1822  maker.addInt( tableDiv, fuResultsList[idx]->faultyEventStats.getSampleCount() );
1823 
1824  if (fuResultsList[idx]->outstandingDataDiscardCount != 0)
1825  {
1826  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1827  }
1828  else
1829  {
1830  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1831  }
1832  maker.addInt( tableDiv, fuResultsList[idx]->outstandingDataDiscardCount );
1833 
1834  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1835  maker.addInt( tableDiv, fuResultsList[idx]->dqmEventStats.getSampleCount() );
1836 
1837  if (fuResultsList[idx]->faultyDQMEventStats.getSampleCount() != 0)
1838  {
1839  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1840  }
1841  else
1842  {
1843  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1844  }
1845  maker.addInt( tableDiv, fuResultsList[idx]->faultyDQMEventStats.getSampleCount() );
1846 
1847  if (fuResultsList[idx]->outstandingDQMDiscardCount != 0)
1848  {
1849  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1850  }
1851  else
1852  {
1853  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1854  }
1855  maker.addInt( tableDiv, fuResultsList[idx]->outstandingDQMDiscardCount );
1856 
1857  const int skippedDiscards = fuResultsList[idx]->skippedDiscardStats.getSampleCount();
1858  if (skippedDiscards != 0)
1859  {
1860  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1861  }
1862  else
1863  {
1864  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1865  }
1866  maker.addInt( tableDiv, skippedDiscards );
1867 
1868  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1869  maker.addDouble( tableDiv, fuResultsList[idx]->shortIntervalEventStats.
1870  getSampleRate(MonitoredQuantity::RECENT) );
1871  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1872  maker.addInt( tableDiv, fuResultsList[idx]->lastEventNumber );
1873  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1874  maker.addInt( tableDiv, fuResultsList[idx]->lastRunNumber );
1875  }
1876  }
1877  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
list key
Definition: combine.py:13
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
std::vector< FUResultPtr > FilterUnitResultsList
void stor::SMWebPageHelper::addFragmentStats ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add statistics for received fragments

Definition at line 557 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentSizeStats, stor::MonitoredQuantity::FULL, and stor::MonitoredQuantity::Stats::getDuration().

563  {
564  // Mean performance header
565  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
566  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow);
567  if ( dataSet == MonitoredQuantity::FULL )
568  maker.addText(tableDiv, "Performance for full run");
569  else
570  maker.addText(tableDiv, "Recent performance for last");
571 
572  addDurationToTableHead(maker, tableRow,
573  stats.allFragmentSizeStats.getDuration(dataSet));
574  addDurationToTableHead(maker, tableRow,
575  stats.eventFragmentSizeStats.getDuration(dataSet));
576  addDurationToTableHead(maker, tableRow,
577  stats.dqmEventFragmentSizeStats.getDuration(dataSet));
578 
579  addRowForFramesReceived(maker, table, stats, dataSet);
580  addRowForBandwidth(maker, table, stats, dataSet);
581  addRowForRate(maker, table, stats, dataSet);
582  addRowForLatency(maker, table, stats, dataSet);
583  if ( dataSet == MonitoredQuantity::FULL )
584  {
585  addRowForTotalVolume(maker, table, stats, dataSet);
586  }
587  else
588  {
589  addRowForMaxBandwidth(maker, table, stats, dataSet);
590  addRowForMinBandwidth(maker, table, stats, dataSet);
591  }
592  }
list table
Definition: asciidump.py:386
void addRowForFramesReceived(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
void addRowForLatency(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
void addRowForMinBandwidth(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
void addDurationToTableHead(XHTMLMaker &maker, XHTMLMaker::Node *tableRow, const utils::Duration_t) const
void addRowForTotalVolume(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
void addRowForBandwidth(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
void addRowForRate(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void addRowForMaxBandwidth(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
void stor::SMWebPageHelper::addOutputModuleStatistics ( XHTMLMaker maker,
XHTMLMaker::Node parent,
long long  uniqueRBID,
DataSenderMonitorCollection const &  dsmc 
) const
private

Adds output module statistics from the specified resource broker to the parent DOM element

Definition at line 1283 of file SMWebPageHelper.cc.

References stor::DataSenderMonitorCollection::getOutputModuleResultsForRB().

1289  {
1291  dsmc.getOutputModuleResultsForRB(uniqueRBID);
1292 
1293  addOutputModuleStatistics(maker, parent, resultsList);
1294  }
list parent
Definition: dbtoconf.py:74
void addOutputModuleStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
std::vector< boost::shared_ptr< OutputModuleResult > > OutputModuleResultsList
void stor::SMWebPageHelper::addOutputModuleStatistics ( XHTMLMaker maker,
XHTMLMaker::Node parent,
DataSenderMonitorCollection::OutputModuleResultsList const &  resultsList 
) const
private

Adds output module statistics to the parent DOM element

Definition at line 1298 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), and stor::XHTMLMaker::addText().

1303  {
1304  XHTMLMaker::AttrMap colspanAttr;
1305  colspanAttr[ "colspan" ] = "7";
1306 
1307  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1308 
1309  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1310  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1311  maker.addText(tableDiv, "Received Data Statistics (by output module)");
1312 
1313  // Header
1314  tableRow = maker.addNode("tr", table, specialRowAttr_);
1315  tableDiv = maker.addNode("th", tableRow);
1316  maker.addText(tableDiv, "Output Module");
1317  tableDiv = maker.addNode("th", tableRow);
1318  maker.addText(tableDiv, "Events");
1319  tableDiv = maker.addNode("th", tableRow);
1320  maker.addText(tableDiv, "Size (MB)");
1321  tableDiv = maker.addNode("th", tableRow);
1322  maker.addText(tableDiv, "Size/Evt (KB)");
1323  tableDiv = maker.addNode("th", tableRow);
1324  maker.addText(tableDiv, "RMS (KB)");
1325  tableDiv = maker.addNode("th", tableRow);
1326  maker.addText(tableDiv, "Min (KB)");
1327  tableDiv = maker.addNode("th", tableRow);
1328  maker.addText(tableDiv, "Max (KB)");
1329 
1330  if (resultsList.empty())
1331  {
1332  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1333  messageAttr[ "align" ] = "center";
1334 
1335  tableRow = maker.addNode("tr", table, rowAttr_);
1336  tableDiv = maker.addNode("td", tableRow, messageAttr);
1337  maker.addText(tableDiv, "No output modules are available yet.");
1338  return;
1339  }
1340  else
1341  {
1342  for (unsigned int idx = 0; idx < resultsList.size(); ++idx)
1343  {
1344  std::string outputModuleLabel = resultsList[idx]->name;
1345 
1346  tableRow = maker.addNode("tr", table, rowAttr_);
1347  tableDiv = maker.addNode("td", tableRow);
1348  maker.addText(tableDiv, outputModuleLabel);
1349  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1350  maker.addInt( tableDiv, resultsList[idx]->eventStats.getSampleCount() );
1351  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1352  maker.addDouble( tableDiv,
1353  resultsList[idx]->eventStats.getValueSum()/(double)0x100000 );
1354  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1355  maker.addDouble( tableDiv,
1356  resultsList[idx]->eventStats.getValueAverage()/(double)0x400 );
1357  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1358  maker.addDouble( tableDiv,
1359  resultsList[idx]->eventStats.getValueRMS()/(double)0x400 );
1360  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1361  maker.addDouble( tableDiv,
1362  resultsList[idx]->eventStats.getValueMin()/(double)0x400 );
1363  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1364  maker.addDouble( tableDiv,
1365  resultsList[idx]->eventStats.getValueMax()/(double)0x400 );
1366  }
1367  }
1368  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addOutputModuleSummary ( XHTMLMaker maker,
XHTMLMaker::Node parent,
DataSenderMonitorCollection::OutputModuleResultsList const &  resultsList 
) const
private

Adds output module summary information to the parent DOM element

Definition at line 1372 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), and mergeVDriftHistosByStation::name.

1377  {
1378  XHTMLMaker::AttrMap colspanAttr;
1379  colspanAttr[ "colspan" ] = "3";
1380 
1381  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1382 
1383  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1384  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1385  maker.addText(tableDiv, "Output Module Summary");
1386 
1387  // Header
1388  tableRow = maker.addNode("tr", table, specialRowAttr_);
1389  tableDiv = maker.addNode("th", tableRow);
1390  maker.addText(tableDiv, "Name");
1391  tableDiv = maker.addNode("th", tableRow);
1392  maker.addText(tableDiv, "ID");
1393  tableDiv = maker.addNode("th", tableRow);
1394  maker.addText(tableDiv, "Header Size (bytes)");
1395 
1396  if (resultsList.empty())
1397  {
1398  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1399  messageAttr[ "align" ] = "center";
1400 
1401  tableRow = maker.addNode("tr", table, rowAttr_);
1402  tableDiv = maker.addNode("td", tableRow, messageAttr);
1403  maker.addText(tableDiv, "No output modules are available yet.");
1404  return;
1405  }
1406  else
1407  {
1408  for (unsigned int idx = 0; idx < resultsList.size(); ++idx)
1409  {
1410  tableRow = maker.addNode("tr", table, rowAttr_);
1411  tableDiv = maker.addNode("td", tableRow);
1412  maker.addText(tableDiv, resultsList[idx]->name);
1413  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1414  maker.addInt( tableDiv, resultsList[idx]->id );
1415  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1416  maker.addInt( tableDiv, resultsList[idx]->initMsgSize );
1417  }
1418  }
1419  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addOutputModuleTables ( XHTMLMaker maker,
XHTMLMaker::Node parent,
DataSenderMonitorCollection const &  dsmc 
) const
private

Adds top-level output module statistics to the parent DOM element

Definition at line 1268 of file SMWebPageHelper.cc.

References stor::DataSenderMonitorCollection::getTopLevelOutputModuleResults().

Referenced by resourceBrokerOverview().

1273  {
1275  dsmc.getTopLevelOutputModuleResults();
1276 
1277  addOutputModuleSummary(maker, parent, resultsList);
1278  addOutputModuleStatistics(maker, parent, resultsList);
1279  }
void addOutputModuleSummary(XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection::OutputModuleResultsList const &) const
list parent
Definition: dbtoconf.py:74
void addOutputModuleStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
std::vector< boost::shared_ptr< OutputModuleResult > > OutputModuleResultsList
void stor::SMWebPageHelper::addResourceBrokerDetails ( XHTMLMaker maker,
XHTMLMaker::Node parent,
long long  uniqueRBID,
DataSenderMonitorCollection const &  dsmc 
) const
private

Adds information about a specific resource broker to the parent DOM element

Definition at line 1579 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::DataSenderMonitorCollection::getOneResourceBrokerResult(), and link().

1585  {
1587  dsmc.getOneResourceBrokerResult(uniqueRBID);
1588 
1589  if (rbResultPtr.get() == 0)
1590  {
1591  maker.addText(parent, "The requested resource broker page is not currently available.");
1592  return;
1593  }
1594 
1595  int tmpDuration;
1596  std::string tmpText;
1597 
1598  XHTMLMaker::AttrMap colspanAttr;
1599  colspanAttr[ "colspan" ] = "2";
1600 
1601  XHTMLMaker::AttrMap tableAttr = tableAttr_;
1602  tableAttr[ "width" ] = "";
1603 
1604  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr);
1605 
1606  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1607  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1608  maker.addText(tableDiv, "Resource Broker Details");
1609 
1610  // Header
1611  tableRow = maker.addNode("tr", table, specialRowAttr_);
1612  tableDiv = maker.addNode("th", tableRow);
1613  maker.addText(tableDiv, "Parameter");
1614  tableDiv = maker.addNode("th", tableRow);
1615  maker.addText(tableDiv, "Value");
1616 
1617  tableRow = maker.addNode("tr", table, rowAttr_);
1618  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1619  maker.addText(tableDiv, "URL");
1620  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1621  XHTMLMaker::AttrMap linkAttr;
1622  linkAttr[ "href" ] = rbResultPtr->key.hltURL + "/urn:xdaq-application:lid=" +
1623  boost::lexical_cast<std::string>(rbResultPtr->key.hltLocalId);
1624  XHTMLMaker::Node* link = maker.addNode("a", tableDiv, linkAttr);
1625  maker.addText(link, rbResultPtr->key.hltURL);
1626 
1627  tableRow = maker.addNode("tr", table, rowAttr_);
1628  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1629  maker.addText(tableDiv, "Class Name");
1630  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1631  maker.addText(tableDiv, rbResultPtr->key.hltClassName);
1632 
1633  tableRow = maker.addNode("tr", table, rowAttr_);
1634  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1635  maker.addText(tableDiv, "Instance");
1636  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1637  maker.addInt( tableDiv, rbResultPtr->key.hltInstance );
1638 
1639  tableRow = maker.addNode("tr", table, rowAttr_);
1640  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1641  maker.addText(tableDiv, "Local ID");
1642  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1643  maker.addInt( tableDiv, rbResultPtr->key.hltLocalId );
1644 
1645  tableRow = maker.addNode("tr", table, rowAttr_);
1646  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1647  maker.addText(tableDiv, "Tid");
1648  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1649  maker.addInt( tableDiv, rbResultPtr->key.hltTid );
1650 
1651  tableRow = maker.addNode("tr", table, rowAttr_);
1652  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1653  maker.addText(tableDiv, "INIT Message Count");
1654  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1655  maker.addInt( tableDiv, rbResultPtr->initMsgCount );
1656 
1657  tableRow = maker.addNode("tr", table, rowAttr_);
1658  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1659  maker.addText(tableDiv, "Event Count");
1660  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1661  maker.addInt( tableDiv, rbResultPtr->eventStats.getSampleCount() );
1662 
1663  tableRow = maker.addNode("tr", table, rowAttr_);
1664  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1665  maker.addText(tableDiv, "Error Event Count");
1666  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1667  maker.addInt( tableDiv, rbResultPtr->errorEventStats.getSampleCount() );
1668 
1669  tableRow = maker.addNode("tr", table, rowAttr_);
1670  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1671  maker.addText(tableDiv, "Faulty Event Count");
1672  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1673  maker.addInt( tableDiv, rbResultPtr->faultyEventStats.getSampleCount() );
1674 
1675  tableRow = maker.addNode("tr", table, rowAttr_);
1676  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1677  maker.addText(tableDiv, "Data Discard Count");
1678  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1679  maker.addInt( tableDiv, rbResultPtr->dataDiscardStats.getSampleCount() );
1680 
1681  tableRow = maker.addNode("tr", table, rowAttr_);
1682  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1683  maker.addText(tableDiv, "DQM Event Count");
1684  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1685  maker.addInt( tableDiv, rbResultPtr->dqmEventStats.getSampleCount() );
1686 
1687  tableRow = maker.addNode("tr", table, rowAttr_);
1688  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1689  maker.addText(tableDiv, "Faulty DQM Event Count");
1690  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1691  maker.addInt( tableDiv, rbResultPtr->faultyDQMEventStats.getSampleCount() );
1692 
1693  tableRow = maker.addNode("tr", table, rowAttr_);
1694  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1695  maker.addText(tableDiv, "DQM Discard Count");
1696  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1697  maker.addInt( tableDiv, rbResultPtr->dqmDiscardStats.getSampleCount() );
1698 
1699  tableRow = maker.addNode("tr", table, rowAttr_);
1700  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1701  maker.addText(tableDiv, "Ignored Discards Count");
1702  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1703  maker.addInt( tableDiv, rbResultPtr->skippedDiscardStats.getSampleCount() );
1704 
1705  tableRow = maker.addNode("tr", table, rowAttr_);
1706  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1707  maker.addText(tableDiv, "Last Event Number Received");
1708  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1709  maker.addInt( tableDiv, rbResultPtr->lastEventNumber );
1710 
1711  tableRow = maker.addNode("tr", table, rowAttr_);
1712  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1713  maker.addText(tableDiv, "Last Run Number Received");
1714  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1715  maker.addInt( tableDiv, rbResultPtr->lastRunNumber );
1716 
1717  tableRow = maker.addNode("tr", table, rowAttr_);
1718  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1719  tmpDuration = rbResultPtr->eventStats.recentDuration.total_seconds();
1720  tmpText = "Recent (" + boost::lexical_cast<std::string>(tmpDuration) +
1721  " sec) Event Rate (Hz)";
1722  maker.addText(tableDiv, tmpText);
1723  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1724  maker.addDouble( tableDiv, rbResultPtr->eventStats.recentSampleRate );
1725 
1726  tableRow = maker.addNode("tr", table, rowAttr_);
1727  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1728  tmpDuration = rbResultPtr->eventStats.fullDuration.total_seconds();
1729  tmpText = "Full (" + boost::lexical_cast<std::string>(tmpDuration) +
1730  " sec) Event Rate (Hz)";
1731  maker.addText(tableDiv, tmpText);
1732  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1733  maker.addDouble( tableDiv, rbResultPtr->eventStats.fullSampleRate );
1734  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::string link(std::string &nm, std::string &ns)
Definition: hierarchy.cc:47
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
boost::shared_ptr< ResourceBrokerResult > RBResultPtr
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addResourceBrokerList ( XHTMLMaker maker,
XHTMLMaker::Node parent,
DataSenderMonitorCollection const &  dsmc 
) const
private

Adds the list of data senders (resource brokers) to the parent DOM element

Definition at line 1423 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::compareRBResultPtrValues(), stor::DataSenderMonitorCollection::getAllResourceBrokerResults(), combine::key, link(), stor::MonitoredQuantity::RECENT, and python.multivaluedict::sort().

Referenced by resourceBrokerOverview().

1428  {
1430  dsmc.getAllResourceBrokerResults();
1431  std::sort(rbResultsList.begin(), rbResultsList.end(), compareRBResultPtrValues);
1432 
1433  XHTMLMaker::AttrMap colspanAttr;
1434  colspanAttr[ "colspan" ] = "15";
1435 
1436  XHTMLMaker::AttrMap tableSuspiciousValueAttr = tableValueAttr_;
1437  tableSuspiciousValueAttr[ "style" ] = "background-color: yellow;";
1438 
1439  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1440 
1441  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1442  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1443  maker.addText(tableDiv, "Data Sender Overview");
1444 
1445  // Header
1446  tableRow = maker.addNode("tr", table, specialRowAttr_);
1447  tableDiv = maker.addNode("th", tableRow);
1448  maker.addText(tableDiv, "Resource Broker URL");
1449  tableDiv = maker.addNode("th", tableRow);
1450  maker.addText(tableDiv, "RB instance");
1451  tableDiv = maker.addNode("th", tableRow);
1452  maker.addText(tableDiv, "RB TID");
1453  tableDiv = maker.addNode("th", tableRow);
1454  maker.addText(tableDiv, "# of FUs");
1455  tableDiv = maker.addNode("th", tableRow);
1456  maker.addText(tableDiv, "# of INIT messages");
1457  tableDiv = maker.addNode("th", tableRow);
1458  maker.addText(tableDiv, "# of events");
1459  tableDiv = maker.addNode("th", tableRow);
1460  maker.addText(tableDiv, "# of error events");
1461  tableDiv = maker.addNode("th", tableRow);
1462  maker.addText(tableDiv, "# of faulty events");
1463  tableDiv = maker.addNode("th", tableRow);
1464  maker.addText(tableDiv, "# of outstanding data discards");
1465  tableDiv = maker.addNode("th", tableRow);
1466  maker.addText(tableDiv, "# of DQM events");
1467  tableDiv = maker.addNode("th", tableRow);
1468  maker.addText(tableDiv, "# of faulty DQM events");
1469  tableDiv = maker.addNode("th", tableRow);
1470  maker.addText(tableDiv, "# of outstanding DQM discards");
1471  tableDiv = maker.addNode("th", tableRow);
1472  maker.addText(tableDiv, "# of ignored discards");
1473  tableDiv = maker.addNode("th", tableRow);
1474  maker.addText(tableDiv, "Recent event rate (Hz)");
1475  tableDiv = maker.addNode("th", tableRow);
1476  maker.addText(tableDiv, "Last event number received");
1477 
1478  if (rbResultsList.empty())
1479  {
1480  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1481  messageAttr[ "align" ] = "center";
1482 
1483  tableRow = maker.addNode("tr", table, rowAttr_);
1484  tableDiv = maker.addNode("td", tableRow, messageAttr);
1485  maker.addText(tableDiv, "No data senders have registered yet.");
1486  return;
1487  }
1488  else
1489  {
1490  for (unsigned int idx = 0; idx < rbResultsList.size(); ++idx)
1491  {
1492  tableRow = maker.addNode("tr", table, rowAttr_);
1493 
1494  tableDiv = maker.addNode("td", tableRow);
1495  XHTMLMaker::AttrMap linkAttr;
1496  linkAttr[ "href" ] = baseURL() + "/rbsenderdetail?id=" +
1497  boost::lexical_cast<std::string>(rbResultsList[idx]->uniqueRBID);
1498  XHTMLMaker::Node* link = maker.addNode("a", tableDiv, linkAttr);
1499  maker.addText(link, rbResultsList[idx]->key.hltURL);
1500 
1501  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1502  maker.addInt( tableDiv, rbResultsList[idx]->key.hltInstance );
1503  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1504  maker.addInt( tableDiv, rbResultsList[idx]->key.hltTid );
1505  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1506  maker.addInt( tableDiv, rbResultsList[idx]->filterUnitCount );
1507  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1508  maker.addInt(tableDiv, rbResultsList[idx]->initMsgCount );
1509  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1510  maker.addInt( tableDiv, rbResultsList[idx]->eventStats.getSampleCount() );
1511  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1512  maker.addInt( tableDiv, rbResultsList[idx]->errorEventStats.getSampleCount() );
1513 
1514  if (rbResultsList[idx]->faultyEventStats.getSampleCount() != 0)
1515  {
1516  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1517  }
1518  else
1519  {
1520  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1521  }
1522  maker.addInt( tableDiv, rbResultsList[idx]->faultyEventStats.getSampleCount() );
1523 
1524  if (rbResultsList[idx]->outstandingDataDiscardCount != 0)
1525  {
1526  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1527  }
1528  else
1529  {
1530  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1531  }
1532  maker.addInt( tableDiv, rbResultsList[idx]->outstandingDataDiscardCount );
1533 
1534  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1535  maker.addInt( tableDiv, rbResultsList[idx]->dqmEventStats.getSampleCount() );
1536 
1537  if (rbResultsList[idx]->faultyDQMEventStats.getSampleCount() != 0)
1538  {
1539  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1540  }
1541  else
1542  {
1543  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1544  }
1545  maker.addInt( tableDiv, rbResultsList[idx]->faultyDQMEventStats.getSampleCount() );
1546 
1547  if (rbResultsList[idx]->outstandingDQMDiscardCount != 0)
1548  {
1549  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1550  }
1551  else
1552  {
1553  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1554  }
1555  maker.addInt( tableDiv, rbResultsList[idx]->outstandingDQMDiscardCount );
1556 
1557  const int skippedDiscards = rbResultsList[idx]->skippedDiscardStats.getSampleCount();
1558  if (skippedDiscards != 0)
1559  {
1560  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1561  }
1562  else
1563  {
1564  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1565  }
1566  maker.addInt( tableDiv, skippedDiscards );
1567 
1568  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1569  maker.addDouble( tableDiv, rbResultsList[idx]->eventStats.
1570  getSampleRate(MonitoredQuantity::RECENT) );
1571  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1572  maker.addInt( tableDiv, rbResultsList[idx]->lastEventNumber );
1573  }
1574  }
1575  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::string link(std::string &nm, std::string &ns)
Definition: hierarchy.cc:47
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
std::vector< RBResultPtr > ResourceBrokerResultsList
list key
Definition: combine.py:13
bool compareRBResultPtrValues(DataSenderMonitorCollection::RBResultPtr firstValue, DataSenderMonitorCollection::RBResultPtr secondValue)
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForBandwidth ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add a table row for fragment bandwidth

Definition at line 616 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentSizeStats, and stor::MonitoredQuantity::Stats::getValueRate().

622  {
623  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
624  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
625  maker.addText(tableDiv, "Bandwidth (MB/s)");
626  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
627  maker.addDouble( tableDiv, stats.allFragmentSizeStats.getValueRate(dataSet) );
628  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
629  maker.addDouble( tableDiv, stats.eventFragmentSizeStats.getValueRate(dataSet) );
630  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
631  maker.addDouble( tableDiv, stats.dqmEventFragmentSizeStats.getValueRate(dataSet) );
632  }
list table
Definition: asciidump.py:386
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForFramesReceived ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add a table row for number of fragment frames received

Definition at line 596 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentSizeStats, and stor::MonitoredQuantity::Stats::getSampleCount().

602  {
603  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
604  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
605  maker.addText(tableDiv, "Frames Received");
606  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
607  maker.addInt( tableDiv, stats.allFragmentSizeStats.getSampleCount(dataSet) );
608  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
609  maker.addInt( tableDiv, stats.eventFragmentSizeStats.getSampleCount(dataSet) );
610  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
611  maker.addInt( tableDiv, stats.dqmEventFragmentSizeStats.getSampleCount(dataSet) );
612  }
list table
Definition: asciidump.py:386
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForLatency ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add a table row for fragment latency

Definition at line 656 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentSizeStats, and stor::MonitoredQuantity::Stats::getSampleLatency().

662  {
663  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
664  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
665  maker.addText(tableDiv, "Latency (us/frame)");
666  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
667  maker.addDouble( tableDiv, stats.allFragmentSizeStats.getSampleLatency(dataSet) );
668  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
669  maker.addDouble( tableDiv, stats.eventFragmentSizeStats.getSampleLatency(dataSet) );
670  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
671  maker.addDouble( tableDiv, stats.dqmEventFragmentSizeStats.getSampleLatency(dataSet) );
672  }
list table
Definition: asciidump.py:386
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForMaxBandwidth ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add a table row for maximum fragment bandwidth

Definition at line 696 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentBandwidthStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentBandwidthStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentBandwidthStats, and stor::MonitoredQuantity::Stats::getValueMax().

702  {
703  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
704  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
705  maker.addText(tableDiv, "Maximum Bandwidth (MB/s)");
706  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
707  maker.addDouble( tableDiv, stats.allFragmentBandwidthStats.getValueMax(dataSet) );
708  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
709  maker.addDouble( tableDiv, stats.eventFragmentBandwidthStats.getValueMax(dataSet) );
710  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
711  maker.addDouble( tableDiv, stats.dqmEventFragmentBandwidthStats.getValueMax(dataSet) );
712  }
list table
Definition: asciidump.py:386
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForMinBandwidth ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add a table row for minimum fragment bandwidth

Definition at line 716 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentBandwidthStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentBandwidthStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentBandwidthStats, and stor::MonitoredQuantity::Stats::getValueMin().

722  {
723  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
724  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
725  maker.addText(tableDiv, "Minimum Bandwidth (MB/s)");
726  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
727  maker.addDouble( tableDiv, stats.allFragmentBandwidthStats.getValueMin(dataSet) );
728  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
729  maker.addDouble( tableDiv, stats.eventFragmentBandwidthStats.getValueMin(dataSet) );
730  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
731  maker.addDouble( tableDiv, stats.dqmEventFragmentBandwidthStats.getValueMin(dataSet) );
732  }
list table
Definition: asciidump.py:386
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForRate ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add a table row for fragment rate

Definition at line 636 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentSizeStats, and stor::MonitoredQuantity::Stats::getSampleRate().

642  {
643  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
644  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
645  maker.addText(tableDiv, "Rate (frames/s)");
646  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
647  maker.addDouble( tableDiv, stats.allFragmentSizeStats.getSampleRate(dataSet) );
648  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
649  maker.addDouble( tableDiv, stats.eventFragmentSizeStats.getSampleRate(dataSet) );
650  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
651  maker.addDouble( tableDiv, stats.dqmEventFragmentSizeStats.getSampleRate(dataSet) );
652  }
list table
Definition: asciidump.py:386
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForThroughputStatistics ( XHTMLMaker maker,
XHTMLMaker::Node table,
const ThroughputMonitorCollection::Stats::Snapshot snapshot,
bool const  isAverage = false 
) const
private

Add table row using the snapshot values

Definition at line 1160 of file SMWebPageHelper.cc.

References stor::ThroughputMonitorCollection::Stats::Snapshot::absoluteTime, stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::ThroughputMonitorCollection::Stats::Snapshot::diskWriterBusy, stor::ThroughputMonitorCollection::Stats::Snapshot::dqmEventProcessorBusy, stor::ThroughputMonitorCollection::Stats::Snapshot::dqmQueueBandwidth, stor::ThroughputMonitorCollection::Stats::Snapshot::dqmQueueRate, stor::ThroughputMonitorCollection::Stats::Snapshot::duration, stor::ThroughputMonitorCollection::Stats::Snapshot::entriesInDQMQueue, stor::ThroughputMonitorCollection::Stats::Snapshot::entriesInFragmentQueue, stor::ThroughputMonitorCollection::Stats::Snapshot::entriesInStreamQueue, stor::ThroughputMonitorCollection::Stats::Snapshot::fragmentProcessorBusy, stor::ThroughputMonitorCollection::Stats::Snapshot::fragmentQueueBandwidth, stor::ThroughputMonitorCollection::Stats::Snapshot::fragmentQueueRate, stor::ThroughputMonitorCollection::Stats::Snapshot::fragmentStoreMemoryUsed, stor::ThroughputMonitorCollection::Stats::Snapshot::fragmentStoreSize, stor::ThroughputMonitorCollection::Stats::Snapshot::memoryUsedInDQMQueue, stor::ThroughputMonitorCollection::Stats::Snapshot::memoryUsedInFragmentQueue, stor::ThroughputMonitorCollection::Stats::Snapshot::memoryUsedInStreamQueue, stor::ThroughputMonitorCollection::Stats::Snapshot::poolUsage, stor::ThroughputMonitorCollection::Stats::Snapshot::streamQueueBandwidth, stor::ThroughputMonitorCollection::Stats::Snapshot::streamQueueRate, stor::utils::timeStampUTC(), stor::ThroughputMonitorCollection::Stats::Snapshot::writtenEventsBandwidth, and stor::ThroughputMonitorCollection::Stats::Snapshot::writtenEventsRate.

1166  {
1167  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1168  XHTMLMaker::Node* tableDiv;
1169  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
1170 
1171  if (isAverage)
1172  {
1173  tableValueAttr[ "style" ] = "background-color: yellow;";
1174  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1175  std::ostringstream avg;
1176  avg << "<" << snapshot.duration.total_seconds() << "s>";
1177  maker.addText(tableDiv, avg.str());
1178  }
1179  else
1180  {
1181  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1182  maker.addText( tableDiv, utils::timeStampUTC(snapshot.absoluteTime) );
1183  }
1184 
1185  // memory pool usage
1186  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1187  maker.addDouble( tableDiv, snapshot.poolUsage, 0 );
1188 
1189  // number of fragments in fragment queue
1190  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1191  maker.addDouble( tableDiv, snapshot.entriesInFragmentQueue, 0 );
1192 
1193  // memory used in fragment queue
1194  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1195  maker.addDouble( tableDiv, snapshot.memoryUsedInFragmentQueue, 1 );
1196 
1197  // number of fragments popped from fragment queue
1198  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1199  maker.addDouble( tableDiv, snapshot.fragmentQueueRate, 0 );
1200 
1201  // data rate popped from fragment queue
1202  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1203  maker.addDouble( tableDiv, snapshot.fragmentQueueBandwidth, 1 );
1204 
1205  // fragment processor thread busy percentage
1206  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1207  maker.addDouble( tableDiv, snapshot.fragmentProcessorBusy, 1 );
1208 
1209  // number of events in fragment store
1210  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1211  maker.addDouble( tableDiv, snapshot.fragmentStoreSize, 0 );
1212 
1213  // memory used in fragment store
1214  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1215  maker.addDouble( tableDiv, snapshot.fragmentStoreMemoryUsed, 1 );
1216 
1217  // number of events in stream queue
1218  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1219  maker.addDouble( tableDiv, snapshot.entriesInStreamQueue, 0 );
1220 
1221  // memory used in stream queue
1222  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1223  maker.addDouble( tableDiv, snapshot.memoryUsedInStreamQueue, 1 );
1224 
1225  // number of events popped from stream queue
1226  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1227  maker.addDouble( tableDiv, snapshot.streamQueueRate, 0 );
1228 
1229  // data rate popped from stream queue
1230  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1231  maker.addDouble( tableDiv, snapshot.streamQueueBandwidth, 1 );
1232 
1233  // disk writer thread busy percentage
1234  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1235  maker.addDouble( tableDiv, snapshot.diskWriterBusy, 1 );
1236 
1237  // number of events written to disk
1238  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1239  maker.addDouble( tableDiv, snapshot.writtenEventsRate, 0 );
1240 
1241  // date rate written to disk
1242  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1243  maker.addDouble( tableDiv, snapshot.writtenEventsBandwidth, 1 );
1244 
1245  // number of dqm events in DQMEvent queue
1246  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1247  maker.addDouble( tableDiv, snapshot.entriesInDQMQueue, 0 );
1248 
1249  // memory used in DQMEvent queue
1250  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1251  maker.addDouble( tableDiv, snapshot.memoryUsedInDQMQueue, 1 );
1252 
1253  // number of dqm events popped from DQMEvent queue
1254  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1255  maker.addDouble( tableDiv, snapshot.dqmQueueRate, 0 );
1256 
1257  // data rate popped from DQMEvent queue
1258  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1259  maker.addDouble( tableDiv, snapshot.dqmQueueBandwidth, 1 );
1260 
1261  // DQMEvent processor thread busy percentage
1262  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1263  maker.addDouble( tableDiv, snapshot.dqmEventProcessorBusy, 1 );
1264  }
list table
Definition: asciidump.py:386
std::string timeStampUTC(TimePoint_t)
Definition: Utils.cc:38
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowForTotalVolume ( XHTMLMaker maker,
XHTMLMaker::Node table,
FragmentMonitorCollection::FragmentStats const &  stats,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

Add a table row for total fragment volume received

Definition at line 676 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::FragmentMonitorCollection::FragmentStats::allFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::dqmEventFragmentSizeStats, stor::FragmentMonitorCollection::FragmentStats::eventFragmentSizeStats, and stor::MonitoredQuantity::Stats::getValueSum().

682  {
683  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
684  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
685  maker.addText(tableDiv, "Total volume received (MB)");
686  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
687  maker.addDouble( tableDiv, stats.allFragmentSizeStats.getValueSum(dataSet), 3 );
688  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
689  maker.addDouble( tableDiv, stats.eventFragmentSizeStats.getValueSum(dataSet), 3 );
690  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
691  maker.addDouble( tableDiv, stats.dqmEventFragmentSizeStats.getValueSum(dataSet), 3 );
692  }
list table
Definition: asciidump.py:386
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowsForMemoryUsage ( XHTMLMaker maker,
XHTMLMaker::Node table,
MonitoredQuantity::Stats const &  stats 
) const
private

Add a table row for memory usage

Definition at line 371 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::MonitoredQuantity::Stats::getLastSampleValue(), and stor::MonitoredQuantity::Stats::getSampleCount().

376  {
377  XHTMLMaker::AttrMap colspanAttr;
378  colspanAttr[ "colspan" ] = "2";
379 
380  XHTMLMaker::AttrMap tableLabelAttr = tableLabelAttr_;
381  tableLabelAttr[ "width" ] = "54%";
382 
383  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
384  tableValueAttr[ "width" ] = "46%";
385 
386  // Memory pool usage
387  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
388  XHTMLMaker::Node* tableDiv;
389  if ( stats.getSampleCount() > 0 )
390  {
391  tableDiv = maker.addNode("td", tableRow);
392  maker.addText(tableDiv, "Memory pool used (bytes)");
393  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
394  maker.addDouble( tableDiv, stats.getLastSampleValue(), 0 );
395  }
396  else
397  {
398  tableDiv = maker.addNode("td", tableRow, colspanAttr);
399  maker.addText(tableDiv, "Memory pool pointer not yet available");
400  }
401  }
list table
Definition: asciidump.py:386
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowsForSataBeast ( XHTMLMaker maker,
XHTMLMaker::Node table,
ResourceMonitorCollection::Stats const &  stats 
) const
private

Add a table row for SATA beast status

Definition at line 431 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::AlarmHandler::ERROR, stor::ResourceMonitorCollection::Stats::sataBeastStatus, and stor::AlarmHandler::WARNING.

436  {
437  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
438  tableValueAttr[ "width" ] = "46%";
439 
440  XHTMLMaker::Node *tableRow, *tableDiv;
441 
442  XHTMLMaker::AttrMap warningAttr = rowAttr_;
443 
444  if (stats.sataBeastStatus < 0 )
445  {
446  warningAttr[ "bgcolor" ] = alarmColors_.find(AlarmHandler::WARNING)->second;
447 
448  XHTMLMaker::AttrMap colspanAttr = tableLabelAttr_;
449  colspanAttr[ "colspan" ] = "2";
450 
451  tableRow = maker.addNode("tr", table, warningAttr);
452  tableDiv = maker.addNode("td", tableRow, colspanAttr);
453  maker.addText(tableDiv, "No SATA disks found");
454  }
455  else
456  {
457  if ( stats.sataBeastStatus > 0 )
458  warningAttr[ "bgcolor" ] = alarmColors_.find(AlarmHandler::ERROR)->second;
459  tableRow = maker.addNode("tr", table, warningAttr);
460  tableDiv = maker.addNode("td", tableRow);
461  maker.addText(tableDiv, "SATA beast status");
462  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
463  maker.addInt( tableDiv, stats.sataBeastStatus );
464  }
465  }
list table
Definition: asciidump.py:386
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
std::map< unsigned int, std::string > alarmColors_
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addRowsForWorkers ( XHTMLMaker maker,
XHTMLMaker::Node table,
ResourceMonitorCollection::Stats const &  stats 
) const
private

Add a table row for copy/inject workers

Definition at line 405 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::ResourceMonitorCollection::Stats::numberOfCopyWorkers, and stor::ResourceMonitorCollection::Stats::numberOfInjectWorkers.

410  {
411  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
412  tableValueAttr[ "width" ] = "46%";
413 
414  // # copy worker
415  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
416  XHTMLMaker::Node* tableDiv = maker.addNode("td", tableRow);
417  maker.addText(tableDiv, "# CopyWorker");
418  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
419  maker.addInt( tableDiv, stats.numberOfCopyWorkers );
420 
421  // # inject worker
422  tableRow = maker.addNode("tr", table, rowAttr_);
423  tableDiv = maker.addNode("td", tableRow);
424  maker.addText(tableDiv, "# InjectWorker");
425  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
426  maker.addInt( tableDiv, stats.numberOfInjectWorkers );
427  }
list table
Definition: asciidump.py:386
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addTableForDiskUsages ( XHTMLMaker maker,
XHTMLMaker::Node parent,
ResourceMonitorCollection::Stats const &  stats 
) const
private

Add a table for disk usage

Definition at line 469 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), and stor::ResourceMonitorCollection::Stats::diskUsageStatsList.

474  {
475  XHTMLMaker::AttrMap colspanAttr;
476  colspanAttr[ "colspan" ] = "2";
477 
478  XHTMLMaker::AttrMap tableLabelAttr = tableLabelAttr_;
479  tableLabelAttr[ "width" ] = "54%";
480 
481  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
482  tableValueAttr[ "width" ] = "46%";
483 
484  XHTMLMaker::AttrMap warningAttr = rowAttr_;
485 
486  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
487  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
488  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
489  maker.addText(tableDiv, "Disk Space Usage");
490 
491 
492  for (ResourceMonitorCollection::DiskUsageStatsPtrList::const_iterator
493  it = stats.diskUsageStatsList.begin(),
494  itEnd = stats.diskUsageStatsList.end();
495  it != itEnd;
496  ++it)
497  {
498  warningAttr[ "bgcolor" ] = alarmColors_.find( (*it)->alarmState )->second;
499  tableRow = maker.addNode("tr", table, warningAttr);
500  tableDiv = maker.addNode("td", tableRow);
501  maker.addText(tableDiv, (*it)->pathName);
502  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
503  if ( (*it)->diskSize > 0 )
504  {
505  std::ostringstream tmpString;
506  tmpString << std::fixed << std::setprecision(0) <<
507  (*it)->relDiskUsage << "% (" <<
508  (*it)->absDiskUsage << " of " <<
509  (*it)->diskSize << " GB)";
510  maker.addText(tableDiv, tmpString.str());
511  }
512  else
513  {
514  maker.addText(tableDiv, "not mounted");
515  }
516  }
517  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
std::map< unsigned int, std::string > alarmColors_
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::addTableForResourceUsages ( XHTMLMaker maker,
XHTMLMaker::Node parent,
ResourceMonitorCollection::Stats const &  rmcStats,
MonitoredQuantity::Stats const &  poolUsageStats 
) const
private

Add a table for resource usage

Definition at line 349 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), and asciidump::table.

355  {
356  XHTMLMaker::AttrMap colspanAttr;
357  colspanAttr[ "colspan" ] = "2";
358 
359  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
360  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
361  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
362  maker.addText(tableDiv, "Resource Usage");
363 
364  addRowsForMemoryUsage(maker, table, poolUsageStats);
365  addRowsForWorkers(maker, table, rmcStats);
366  addRowsForSataBeast(maker, table, rmcStats);
367  }
list table
Definition: asciidump.py:386
list parent
Definition: dbtoconf.py:74
void addRowsForWorkers(XHTMLMaker &maker, XHTMLMaker::Node *table, ResourceMonitorCollection::Stats const &) const
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
void addRowsForSataBeast(XHTMLMaker &maker, XHTMLMaker::Node *table, ResourceMonitorCollection::Stats const &) const
void addRowsForMemoryUsage(XHTMLMaker &maker, XHTMLMaker::Node *table, MonitoredQuantity::Stats const &) const
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::consumerStatistics ( xgi::Output out) const

Generates consumer statistics page

Definition at line 122 of file SMWebPageHelper.cc.

References stor::ConsumerWebPageHelper< WebPageHelper_t, EventQueueCollection_t, StatisticsReporter_t >::consumerStatistics(), consumerWebPageHelper_, stor::StateMachineMonitorCollection::externallyVisibleState(), stor::StateMachineMonitorCollection::innerStateName(), sharedResources_, and stor::StateMachineMonitorCollection::statusMessage().

123  {
124  const StateMachineMonitorCollection& stateMachineMonitorCollection =
125  sharedResources_->statisticsReporter_->getStateMachineMonitorCollection();
126 
127  std::string errorMsg;
128  stateMachineMonitorCollection.statusMessage(errorMsg);
129 
131  stateMachineMonitorCollection.externallyVisibleState(),
132  stateMachineMonitorCollection.innerStateName(),
133  errorMsg,
134  sharedResources_->statisticsReporter_,
135  sharedResources_->registrationCollection_,
136  sharedResources_->eventQueueCollection_,
137  sharedResources_->dqmEventQueueCollection_
138  );
139  }
ConsumerWebPageHelper_t consumerWebPageHelper_
tuple out
Definition: dbtoconf.py:99
SharedResourcesPtr sharedResources_
void consumerStatistics(xgi::Output *, const std::string &externallyVisibleState, const std::string &innerStateName, const std::string &errorMsg, boost::shared_ptr< StatisticsReporter_t >, RegistrationCollectionPtr, boost::shared_ptr< EventQueueCollection_t >, DQMEventQueueCollectionPtr) const
XHTMLMaker::Node * stor::SMWebPageHelper::createWebPageBody ( XHTMLMaker maker,
const std::string &  pageTitle,
const StateMachineMonitorCollection stateMachineMonitorCollection 
) const
private

Returns the webpage body with the standard header as XHTML node

Definition at line 243 of file SMWebPageHelper.cc.

References stor::WebPageHelper< T >::createWebPageBody(), stor::StateMachineMonitorCollection::externallyVisibleState(), stor::StateMachineMonitorCollection::innerStateName(), and stor::StateMachineMonitorCollection::statusMessage().

Referenced by defaultWebPage(), dqmEventWebPage(), filesWebPage(), resourceBrokerOverview(), storedDataWebPage(), and throughputWebPage().

248  {
249  std::string errorMsg;
250  stateMachineMonitorCollection.statusMessage(errorMsg);
251 
253  maker,
254  pageTitle,
255  stateMachineMonitorCollection.externallyVisibleState(),
256  stateMachineMonitorCollection.innerStateName(),
257  errorMsg
258  );
259  }
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const std::string &externallyVisibleState, const std::string &innerStateName, const std::string &errorMsg) const
void stor::SMWebPageHelper::defaultWebPage ( xgi::Output out) const

Generates the default monitoring webpage

Definition at line 48 of file SMWebPageHelper.cc.

References addDOMforFragmentMonitor(), addDOMforHyperLinks(), addDOMforResourceUsage(), addDOMforRunMonitor(), createWebPageBody(), stor::XHTMLMaker::out(), and sharedResources_.

49  {
50  XHTMLMonitor theMonitor;
51  XHTMLMaker maker;
52 
53  StatisticsReporterPtr statReporter = sharedResources_->statisticsReporter_;
54 
55  // Create the body with the standard header
56  XHTMLMaker::Node* body = createWebPageBody(maker, "Main",
57  statReporter->getStateMachineMonitorCollection());
58 
59  // Run and event summary
60  addDOMforRunMonitor(maker, body, statReporter->getRunMonitorCollection());
61 
62  // Resource usage
63  addDOMforResourceUsage(maker, body,
64  statReporter->getResourceMonitorCollection(),
65  statReporter->getThroughputMonitorCollection());
66 
67  // Add the received data statistics table
68  addDOMforFragmentMonitor(maker, body,
69  statReporter->getFragmentMonitorCollection());
70 
71  addDOMforHyperLinks(maker, body);
72 
73  // Dump the webpage to the output stream
74  maker.out(*out);
75  }
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:60
void addDOMforFragmentMonitor(XHTMLMaker &maker, XHTMLMaker::Node *parent, FragmentMonitorCollection const &) const
void addDOMforResourceUsage(XHTMLMaker &, XHTMLMaker::Node *parent, ResourceMonitorCollection const &, ThroughputMonitorCollection const &) const
tuple out
Definition: dbtoconf.py:99
SharedResourcesPtr sharedResources_
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void addDOMforRunMonitor(XHTMLMaker &maker, XHTMLMaker::Node *parent, RunMonitorCollection const &) const
void stor::SMWebPageHelper::dqmEventWebPage ( xgi::Output out) const

Generates the DQM event processor monitoring webpage

Definition at line 201 of file SMWebPageHelper.cc.

References stor::WebPageHelper< SMWebPageHelper >::addDOMforDQMEventStatistics(), addDOMforHyperLinks(), stor::WebPageHelper< SMWebPageHelper >::addDOMforProcessedDQMEvents(), createWebPageBody(), stor::XHTMLMaker::out(), and sharedResources_.

202  {
203  XHTMLMonitor theMonitor;
204  XHTMLMaker maker;
205 
206  StatisticsReporterPtr statReporter = sharedResources_->statisticsReporter_;
207 
208  // Create the body with the standard header
209  XHTMLMaker::Node* body = createWebPageBody(maker, "DQM Event Processor",
210  statReporter->getStateMachineMonitorCollection());
211 
212  addDOMforProcessedDQMEvents(maker, body, statReporter->getDQMEventMonitorCollection());
213  addDOMforDQMEventStatistics(maker, body, statReporter->getDQMEventMonitorCollection());
214 
215  addDOMforHyperLinks(maker, body);
216 
217  // Dump the webpage to the output stream
218  maker.out(*out);
219  }
void addDOMforDQMEventStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, DQMEventMonitorCollection const &) const
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:60
void addDOMforProcessedDQMEvents(XHTMLMaker &maker, XHTMLMaker::Node *parent, DQMEventMonitorCollection const &) const
tuple out
Definition: dbtoconf.py:99
SharedResourcesPtr sharedResources_
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::filesWebPage ( xgi::Output out) const

Generates the files monitoring webpage

Definition at line 102 of file SMWebPageHelper.cc.

References addDOMforFiles(), addDOMforHyperLinks(), createWebPageBody(), stor::XHTMLMaker::out(), and sharedResources_.

103  {
104  XHTMLMonitor theMonitor;
105  XHTMLMaker maker;
106 
107  StatisticsReporterPtr statReporter = sharedResources_->statisticsReporter_;
108 
109  // Create the body with the standard header
110  XHTMLMaker::Node* body = createWebPageBody(maker, "Files",
111  statReporter->getStateMachineMonitorCollection());
112 
113  addDOMforFiles(maker, body, statReporter->getFilesMonitorCollection());
114 
115  addDOMforHyperLinks(maker, body);
116 
117  // Dump the webpage to the output stream
118  maker.out(*out);
119  }
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
void addDOMforFiles(XHTMLMaker &maker, XHTMLMaker::Node *parent, FilesMonitorCollection const &) const
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:60
tuple out
Definition: dbtoconf.py:99
SharedResourcesPtr sharedResources_
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::listStreamRecordsStats ( XHTMLMaker maker,
XHTMLMaker::Node table,
StreamsMonitorCollection const &  smc,
const MonitoredQuantity::DataSetType  dataSet 
) const
private

List stream records statistics

Definition at line 925 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::addDouble(), stor::XHTMLMaker::addInt(), stor::XHTMLMaker::addNode(), stor::XHTMLMaker::addText(), stor::StreamsMonitorCollection::getAllStreamsBandwidthMQ(), stor::StreamsMonitorCollection::getAllStreamsFileCountMQ(), stor::StreamsMonitorCollection::getAllStreamsVolumeMQ(), stor::MonitoredQuantity::Stats::getSampleCount(), stor::MonitoredQuantity::Stats::getSampleRate(), stor::MonitoredQuantity::getStats(), stor::StreamsMonitorCollection::getStreamRecords(), stor::MonitoredQuantity::Stats::getValueMax(), stor::MonitoredQuantity::Stats::getValueMin(), stor::MonitoredQuantity::Stats::getValueRate(), and stor::MonitoredQuantity::Stats::getValueSum().

931  {
933  smc.getStreamRecords(streamRecords);
934  MonitoredQuantity::Stats allStreamsFileCountStats;
935  smc.getAllStreamsFileCountMQ().getStats(allStreamsFileCountStats);
936  MonitoredQuantity::Stats allStreamsVolumeStats;
937  smc.getAllStreamsVolumeMQ().getStats(allStreamsVolumeStats);
938  MonitoredQuantity::Stats allStreamsBandwidthStats;
939  smc.getAllStreamsBandwidthMQ().getStats(allStreamsBandwidthStats);
940 
941  XHTMLMaker::Node *tableRow, *tableDiv;
942 
943  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
944  tableValueAttr[ "width" ] = "11%";
945 
946 
947  for (
948  StreamsMonitorCollection::StreamRecordList::const_iterator
949  it = streamRecords.begin(), itEnd = streamRecords.end();
950  it != itEnd;
951  ++it
952  )
953  {
954  MonitoredQuantity::Stats streamFileCountStats;
955  (*it)->fileCount.getStats(streamFileCountStats);
956  MonitoredQuantity::Stats streamVolumeStats;
957  (*it)->volume.getStats(streamVolumeStats);
958  MonitoredQuantity::Stats streamBandwidthStats;
959  (*it)->bandwidth.getStats(streamBandwidthStats);
960 
961 
962  tableRow = maker.addNode("tr", table, rowAttr_);
963  tableDiv = maker.addNode("td", tableRow);
964  maker.addText(tableDiv, (*it)->streamName);
965  tableDiv = maker.addNode("td", tableRow);
966  maker.addDouble(tableDiv, (*it)->fractionToDisk, 2);
967  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
968  maker.addInt( tableDiv, streamFileCountStats.getSampleCount(dataSet) );
969  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
970  maker.addInt( tableDiv, streamVolumeStats.getSampleCount(dataSet) );
971  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
972  maker.addDouble( tableDiv, streamVolumeStats.getSampleRate(dataSet), 1 );
973  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
974  maker.addDouble( tableDiv, streamVolumeStats.getValueSum(dataSet), 1 );
975  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
976  maker.addDouble( tableDiv, streamBandwidthStats.getValueRate(dataSet) );
977  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
978  maker.addDouble( tableDiv, streamBandwidthStats.getValueMin(dataSet) );
979  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
980  maker.addDouble( tableDiv, streamBandwidthStats.getValueMax(dataSet) );
981  }
982 
983  tableRow = maker.addNode("tr", table, specialRowAttr_);
984  tableDiv = maker.addNode("td", tableRow);
985  maker.addText(tableDiv, "Total");
986  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
987  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
988  maker.addInt( tableDiv, allStreamsFileCountStats.getSampleCount(dataSet) );
989  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
990  maker.addInt( tableDiv, allStreamsVolumeStats.getSampleCount(dataSet) );
991  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
992  maker.addDouble( tableDiv, allStreamsVolumeStats.getSampleRate(dataSet), 1 );
993  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
994  maker.addDouble( tableDiv, allStreamsVolumeStats.getValueSum(dataSet), 1 );
995  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
996  maker.addDouble( tableDiv, allStreamsBandwidthStats.getValueRate(dataSet) );
997  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
998  maker.addDouble( tableDiv, allStreamsBandwidthStats.getValueMin(dataSet) );
999  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1000  maker.addDouble( tableDiv, allStreamsBandwidthStats.getValueMax(dataSet) );
1001  }
list table
Definition: asciidump.py:386
std::vector< StreamRecordPtr > StreamRecordList
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
SMWebPageHelper& stor::SMWebPageHelper::operator= ( SMWebPageHelper const &  )
private
void stor::SMWebPageHelper::resourceBrokerDetail ( xgi::Output out,
const long long &  uniqueRBID 
) const

Generates the data sender web page for a specific resource broker

Definition at line 169 of file SMWebPageHelper.cc.

References stor::XHTMLMaker::out().

173  {
174  XHTMLMonitor theMonitor;
175  XHTMLMaker maker;
176 
177  StatisticsReporterPtr statReporter = sharedResources_->statisticsReporter_;
178 
179  // Create the body with the standard header
180  std::ostringstream pageTitle;
181  pageTitle << "Resource Broker " << uniqueRBID << " Detail";
182  XHTMLMaker::Node* body = createWebPageBody(maker, pageTitle.str(),
183  statReporter->getStateMachineMonitorCollection());
184 
185  addResourceBrokerDetails(maker, body, uniqueRBID,
186  statReporter->getDataSenderMonitorCollection());
187 
188  addOutputModuleStatistics(maker, body, uniqueRBID,
189  statReporter->getDataSenderMonitorCollection());
190 
191  addFilterUnitList(maker, body, uniqueRBID,
192  statReporter->getDataSenderMonitorCollection());
193 
194  addDOMforHyperLinks(maker, body);
195 
196  // Dump the webpage to the output stream
197  maker.out(*out);
198  }
void addOutputModuleStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:60
void addFilterUnitList(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
tuple out
Definition: dbtoconf.py:99
void addResourceBrokerDetails(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
SharedResourcesPtr sharedResources_
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::resourceBrokerOverview ( xgi::Output out) const

Generates the data sender web page for all resource brokers

Definition at line 142 of file SMWebPageHelper.cc.

References addDOMforHyperLinks(), stor::XHTMLMaker::addNode(), addOutputModuleTables(), addResourceBrokerList(), createWebPageBody(), stor::XHTMLMaker::out(), and sharedResources_.

143  {
144  XHTMLMonitor theMonitor;
145  XHTMLMaker maker;
146 
147  StatisticsReporterPtr statReporter = sharedResources_->statisticsReporter_;
148 
149  // Create the body with the standard header
150  XHTMLMaker::Node* body = createWebPageBody(maker, "Resource Broker Overview",
151  statReporter->getStateMachineMonitorCollection());
152 
153  addOutputModuleTables(maker, body,
154  statReporter->getDataSenderMonitorCollection());
155 
156  maker.addNode("hr", body);
157 
158  addResourceBrokerList(maker, body,
159  statReporter->getDataSenderMonitorCollection());
160 
161  addDOMforHyperLinks(maker, body);
162 
163  // Dump the webpage to the output stream
164  maker.out(*out);
165  }
void addOutputModuleTables(XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection const &) const
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:60
tuple out
Definition: dbtoconf.py:99
SharedResourcesPtr sharedResources_
void addResourceBrokerList(XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection const &) const
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::storedDataWebPage ( xgi::Output out) const

Generates the output streams monitoring webpage

Definition at line 78 of file SMWebPageHelper.cc.

References addDOMforConfigString(), addDOMforHyperLinks(), addDOMforStoredData(), stor::XHTMLMaker::addNode(), createWebPageBody(), stor::XHTMLMaker::out(), and sharedResources_.

79  {
80  XHTMLMonitor theMonitor;
81  XHTMLMaker maker;
82 
83  StatisticsReporterPtr statReporter = sharedResources_->statisticsReporter_;
84 
85  // Create the body with the standard header
86  XHTMLMaker::Node* body = createWebPageBody(maker, "Stored Data",
87  statReporter->getStateMachineMonitorCollection());
88 
89  addDOMforStoredData(maker, body, statReporter->getStreamsMonitorCollection());
90 
91  maker.addNode("hr", body);
92 
93  addDOMforConfigString(maker, body, sharedResources_->configuration_->getDiskWritingParams());
94 
95  addDOMforHyperLinks(maker, body);
96 
97  // Dump the webpage to the output stream
98  maker.out(*out);
99  }
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:60
void addDOMforStoredData(XHTMLMaker &maker, XHTMLMaker::Node *parent, StreamsMonitorCollection const &) const
tuple out
Definition: dbtoconf.py:99
SharedResourcesPtr sharedResources_
void addDOMforConfigString(XHTMLMaker &maker, XHTMLMaker::Node *parent, DiskWritingParams const &) const
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
void stor::SMWebPageHelper::throughputWebPage ( xgi::Output out) const

Generates the throughput monitoring webpage

Definition at line 222 of file SMWebPageHelper.cc.

References addDOMforHyperLinks(), addDOMforThroughputStatistics(), createWebPageBody(), stor::XHTMLMaker::out(), and sharedResources_.

223  {
224  XHTMLMonitor theMonitor;
225  XHTMLMaker maker;
226 
227  StatisticsReporterPtr statReporter = sharedResources_->statisticsReporter_;
228 
229  // Create the body with the standard header
230  XHTMLMaker::Node* body = createWebPageBody(maker, "Throughput",
231  statReporter->getStateMachineMonitorCollection());
232 
233  addDOMforThroughputStatistics(maker, body, statReporter->getThroughputMonitorCollection());
234 
235  addDOMforHyperLinks(maker, body);
236 
237  // Dump the webpage to the output stream
238  maker.out(*out);
239  }
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:60
tuple out
Definition: dbtoconf.py:99
void addDOMforThroughputStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, ThroughputMonitorCollection const &) const
SharedResourcesPtr sharedResources_
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35

Member Data Documentation

ConsumerWebPageHelper_t stor::SMWebPageHelper::consumerWebPageHelper_
private

Definition at line 432 of file SMWebPageHelper.h.

Referenced by consumerStatistics().

SharedResourcesPtr stor::SMWebPageHelper::sharedResources_
private