CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
SMWebPageHelper.cc
Go to the documentation of this file.
1 // $Id: SMWebPageHelper.cc,v 1.2 2011/03/07 15:31:32 mommsen Exp $
3 
4 #ifdef __APPLE__
5 #include <sys/param.h>
6 #include <sys/mount.h>
7 #else
8 #include <sys/statfs.h>
9 #endif
10 
11 #include <iomanip>
12 #include <iostream>
13 #include <sstream>
14 #include <stdio.h>
15 
16 #include "boost/lexical_cast.hpp"
17 
18 #include "EventFilter/StorageManager/interface/AlarmHandler.h"
19 #include "EventFilter/StorageManager/interface/EventConsumerMonitorCollection.h"
20 #include "EventFilter/StorageManager/interface/FilesMonitorCollection.h"
21 #include "EventFilter/StorageManager/interface/FragmentMonitorCollection.h"
22 #include "EventFilter/StorageManager/interface/MonitoredQuantity.h"
23 #include "EventFilter/StorageManager/interface/RegistrationCollection.h"
24 #include "EventFilter/StorageManager/interface/ResourceMonitorCollection.h"
25 #include "EventFilter/StorageManager/interface/RunMonitorCollection.h"
26 #include "EventFilter/StorageManager/interface/StreamsMonitorCollection.h"
27 #include "EventFilter/StorageManager/interface/SMWebPageHelper.h"
28 #include "EventFilter/StorageManager/interface/XHTMLMonitor.h"
29 #include "EventFilter/StorageManager/src/ConsumerWebPageHelper.icc"
30 
31 #include "toolbox/net/Utils.h"
32 
33 
34 namespace stor
35 {
36 
37  SMWebPageHelper::SMWebPageHelper
38  (
39  xdaq::ApplicationDescriptor* appDesc,
40  SharedResourcesPtr sharedResources
41  ) :
42  WebPageHelper<SMWebPageHelper>(appDesc, "$Name: $", this, &stor::SMWebPageHelper::addDOMforHyperLinks),
43  sharedResources_(sharedResources),
44  consumerWebPageHelper_(appDesc, "$Name: $", this, &stor::SMWebPageHelper::addDOMforHyperLinks)
45  {}
46 
47 
48  void SMWebPageHelper::defaultWebPage(xgi::Output *out) const
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  }
76 
77 
78  void SMWebPageHelper::storedDataWebPage(xgi::Output *out) const
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  }
100 
101 
102  void SMWebPageHelper::filesWebPage(xgi::Output *out) const
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  }
120 
121 
122  void SMWebPageHelper::consumerStatistics(xgi::Output *out) const
123  {
124  const StateMachineMonitorCollection& stateMachineMonitorCollection =
125  sharedResources_->statisticsReporter_->getStateMachineMonitorCollection();
126 
127  std::string errorMsg;
128  stateMachineMonitorCollection.statusMessage(errorMsg);
129 
130  consumerWebPageHelper_.consumerStatistics(out,
131  stateMachineMonitorCollection.externallyVisibleState(),
132  stateMachineMonitorCollection.innerStateName(),
133  errorMsg,
134  sharedResources_->statisticsReporter_,
135  sharedResources_->registrationCollection_,
136  sharedResources_->eventQueueCollection_,
137  sharedResources_->dqmEventQueueCollection_
138  );
139  }
140 
141 
142  void SMWebPageHelper::resourceBrokerOverview(xgi::Output *out) const
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  }
166 
167 
168  void SMWebPageHelper::resourceBrokerDetail
169  (
170  xgi::Output *out,
171  const long long& uniqueRBID
172  ) const
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  }
199 
200 
201  void SMWebPageHelper::dqmEventWebPage(xgi::Output* out) const
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  }
220 
221 
222  void SMWebPageHelper::throughputWebPage(xgi::Output *out) const
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  }
240 
241 
242  XHTMLMaker::Node* SMWebPageHelper::createWebPageBody
243  (
244  XHTMLMaker& maker,
245  const std::string& pageTitle,
246  const StateMachineMonitorCollection& stateMachineMonitorCollection
247  ) const
248  {
249  std::string errorMsg;
250  stateMachineMonitorCollection.statusMessage(errorMsg);
251 
252  return WebPageHelper<SMWebPageHelper>::createWebPageBody(
253  maker,
254  pageTitle,
255  stateMachineMonitorCollection.externallyVisibleState(),
256  stateMachineMonitorCollection.innerStateName(),
257  errorMsg
258  );
259  }
260 
261 
262  void SMWebPageHelper::addDOMforHyperLinks
263  (
264  XHTMLMaker& maker,
265  XHTMLMaker::Node *parent
266  ) const
267  {
268  std::string url = appDescriptor_->getContextDescriptor()->getURL()
269  + "/" + appDescriptor_->getURN();
270 
271  XHTMLMaker::AttrMap linkAttr;
272  XHTMLMaker::Node *link;
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  }
318 
319 
320  void SMWebPageHelper::addDOMforResourceUsage
321  (
322  XHTMLMaker& maker,
323  XHTMLMaker::Node *parent,
324  ResourceMonitorCollection const& rmc,
325  ThroughputMonitorCollection const& tmc
326  ) const
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  }
346 
347 
348  void SMWebPageHelper::addTableForResourceUsages
349  (
350  XHTMLMaker& maker,
351  XHTMLMaker::Node *parent,
352  ResourceMonitorCollection::Stats const& rmcStats,
353  MonitoredQuantity::Stats const& poolUsageStats
354  ) const
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  }
368 
369 
370  void SMWebPageHelper::addRowsForMemoryUsage
371  (
372  XHTMLMaker& maker,
373  XHTMLMaker::Node *table,
374  MonitoredQuantity::Stats const& stats
375  ) const
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  }
402 
403 
404  void SMWebPageHelper::addRowsForWorkers
405  (
406  XHTMLMaker& maker,
407  XHTMLMaker::Node *table,
408  ResourceMonitorCollection::Stats const& stats
409  ) const
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  }
428 
429 
430  void SMWebPageHelper::addRowsForSataBeast
431  (
432  XHTMLMaker& maker,
433  XHTMLMaker::Node *table,
434  ResourceMonitorCollection::Stats const& stats
435  ) const
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  }
466 
467 
468  void SMWebPageHelper::addTableForDiskUsages
469  (
470  XHTMLMaker& maker,
471  XHTMLMaker::Node *parent,
472  ResourceMonitorCollection::Stats const& stats
473  ) const
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  }
518 
519 
520  void SMWebPageHelper::addDOMforFragmentMonitor
521  (
522  XHTMLMaker& maker,
523  XHTMLMaker::Node *parent,
524  FragmentMonitorCollection const& fmc
525  ) const
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 
551  addFragmentStats(maker, table, stats, MonitoredQuantity::FULL);
552 
553  addFragmentStats(maker, table, stats, MonitoredQuantity::RECENT);
554  }
555 
556  void SMWebPageHelper::addFragmentStats
557  (
558  XHTMLMaker& maker,
559  XHTMLMaker::Node *table,
560  FragmentMonitorCollection::FragmentStats const& stats,
561  const MonitoredQuantity::DataSetType dataSet
562  ) const
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  }
593 
594 
595  void SMWebPageHelper::addRowForFramesReceived
596  (
597  XHTMLMaker& maker,
598  XHTMLMaker::Node *table,
599  FragmentMonitorCollection::FragmentStats const& stats,
600  const MonitoredQuantity::DataSetType dataSet
601  ) const
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  }
613 
614 
615  void SMWebPageHelper::addRowForBandwidth
616  (
617  XHTMLMaker& maker,
618  XHTMLMaker::Node *table,
619  FragmentMonitorCollection::FragmentStats const& stats,
620  const MonitoredQuantity::DataSetType dataSet
621  ) const
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  }
633 
634 
635  void SMWebPageHelper::addRowForRate
636  (
637  XHTMLMaker& maker,
638  XHTMLMaker::Node *table,
639  FragmentMonitorCollection::FragmentStats const& stats,
640  const MonitoredQuantity::DataSetType dataSet
641  ) const
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  }
653 
654 
655  void SMWebPageHelper::addRowForLatency
656  (
657  XHTMLMaker& maker,
658  XHTMLMaker::Node *table,
659  FragmentMonitorCollection::FragmentStats const& stats,
660  const MonitoredQuantity::DataSetType dataSet
661  ) const
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  }
673 
674 
675  void SMWebPageHelper::addRowForTotalVolume
676  (
677  XHTMLMaker& maker,
678  XHTMLMaker::Node *table,
679  FragmentMonitorCollection::FragmentStats const& stats,
680  const MonitoredQuantity::DataSetType dataSet
681  ) const
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  }
693 
694 
695  void SMWebPageHelper::addRowForMaxBandwidth
696  (
697  XHTMLMaker& maker,
698  XHTMLMaker::Node *table,
699  FragmentMonitorCollection::FragmentStats const& stats,
700  const MonitoredQuantity::DataSetType dataSet
701  ) const
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  }
713 
714 
715  void SMWebPageHelper::addRowForMinBandwidth
716  (
717  XHTMLMaker& maker,
718  XHTMLMaker::Node *table,
719  FragmentMonitorCollection::FragmentStats const& stats,
720  const MonitoredQuantity::DataSetType dataSet
721  ) const
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  }
733 
734 
735  void SMWebPageHelper::addDOMforRunMonitor
736  (
737  XHTMLMaker& maker,
738  XHTMLMaker::Node *parent,
739  RunMonitorCollection const& rmc
740  ) const
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  }
812 
813 
814  void SMWebPageHelper::addDOMforStoredData
815  (
816  XHTMLMaker& maker,
817  XHTMLMaker::Node *parent,
818  StreamsMonitorCollection const& smc
819  ) const
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  }
884  listStreamRecordsStats(maker, table, smc, MonitoredQuantity::FULL);
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  }
896  listStreamRecordsStats(maker, table, smc, MonitoredQuantity::RECENT);
897  }
898 
899 
900  void SMWebPageHelper::addDOMforConfigString
901  (
902  XHTMLMaker& maker,
903  XHTMLMaker::Node *parent,
904  DiskWritingParams const& dwParams
905  ) const
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  }
922 
923 
924  void SMWebPageHelper::listStreamRecordsStats
925  (
926  XHTMLMaker& maker,
927  XHTMLMaker::Node *table,
928  StreamsMonitorCollection const& smc,
929  const MonitoredQuantity::DataSetType dataSet
930  ) const
931  {
932  StreamsMonitorCollection::StreamRecordList streamRecords;
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  }
1002 
1003 
1004  void SMWebPageHelper::addDOMforFiles
1005  (
1006  XHTMLMaker& maker,
1007  XHTMLMaker::Node *parent,
1008  FilesMonitorCollection const& fmc
1009  ) const
1010  {
1011  FilesMonitorCollection::FileRecordList fileRecords;
1012  fmc.getFileRecords(fileRecords);
1013 
1014  XHTMLMaker::AttrMap colspanAttr;
1015  colspanAttr[ "colspan" ] = "5";
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 
1045  // File list
1046  if (fileRecords.empty())
1047  {
1048  tableRow = maker.addNode("tr", table, rowAttr_);
1049  tableDiv = maker.addNode("td", tableRow, colspanAttr);
1050  maker.addText(tableDiv, "no files available yet");
1051  return;
1052  }
1053 
1054  for (
1055  FilesMonitorCollection::FileRecordList::const_reverse_iterator
1056  it = fileRecords.rbegin(), itEnd = fileRecords.rend();
1057  it != itEnd;
1058  ++it
1059  )
1060  {
1061  tableRow = maker.addNode("tr", table, rowAttr_);
1062  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1063  maker.addInt( tableDiv, (*it)->entryCounter );
1064  tableDiv = maker.addNode("td", tableRow);
1065  maker.addText(tableDiv, (*it)->completeFileName());
1066  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1067  maker.addInt( tableDiv, (*it)->eventCount );
1068  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1069  maker.addInt( tableDiv, (*it)->fileSize );
1070  tableDiv = maker.addNode("td", tableRow, tableLabelAttr);
1071  maker.addText(tableDiv, (*it)->closingReason());
1072  }
1073  }
1074 
1075 
1076  void SMWebPageHelper::addDOMforThroughputStatistics
1077  (
1078  XHTMLMaker& maker,
1079  XHTMLMaker::Node *parent,
1080  ThroughputMonitorCollection const& tmc
1081  ) const
1082  {
1083  XHTMLMaker::AttrMap colspanAttr;
1084  colspanAttr[ "colspan" ] = "21";
1085 
1086  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1087 
1088  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1089  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1090  maker.addText(tableDiv, "Throughput Statistics");
1091 
1092  // Header
1093  tableRow = maker.addNode("tr", table, specialRowAttr_);
1094  tableDiv = maker.addNode("th", tableRow);
1095  maker.addText(tableDiv, "Time (UTC)");
1096  tableDiv = maker.addNode("th", tableRow);
1097  maker.addText(tableDiv, "Memory pool usage (bytes)");
1098  tableDiv = maker.addNode("th", tableRow);
1099  maker.addText(tableDiv, "Instantaneous Number of Fragments in Fragment Queue");
1100  tableDiv = maker.addNode("th", tableRow);
1101  maker.addText(tableDiv, "Memory used in Fragment Queue (MB)");
1102  tableDiv = maker.addNode("th", tableRow);
1103  maker.addText(tableDiv, "Number of Fragments Popped from Fragment Queue (Hz)");
1104  tableDiv = maker.addNode("th", tableRow);
1105  maker.addText(tableDiv, "Data Rate Popped from Fragment Queue (MB/sec)");
1106  tableDiv = maker.addNode("th", tableRow);
1107  maker.addText(tableDiv, "Fragment Processor Thread Busy Percentage");
1108  tableDiv = maker.addNode("th", tableRow);
1109  maker.addText(tableDiv, "Instantaneous Number of Events in Fragment Store");
1110  tableDiv = maker.addNode("th", tableRow);
1111  maker.addText(tableDiv, "Memory used in Fragment Store (MB)");
1112  tableDiv = maker.addNode("th", tableRow);
1113  maker.addText(tableDiv, "Instantaneous Number of Events in Stream Queue");
1114  tableDiv = maker.addNode("th", tableRow);
1115  maker.addText(tableDiv, "Memory used in Stream Queue (MB)");
1116  tableDiv = maker.addNode("th", tableRow);
1117  maker.addText(tableDiv, "Number of Events Popped from Stream Queue (Hz)");
1118  tableDiv = maker.addNode("th", tableRow);
1119  maker.addText(tableDiv, "Data Rate Popped from Stream Queue (MB/sec)");
1120  tableDiv = maker.addNode("th", tableRow);
1121  maker.addText(tableDiv, "Disk Writer Thread Busy Percentage");
1122  tableDiv = maker.addNode("th", tableRow);
1123  maker.addText(tableDiv, "Number of Events Written to Disk (Hz)");
1124  tableDiv = maker.addNode("th", tableRow);
1125  maker.addText(tableDiv, "Data Rate to Disk (MB/sec)");
1126  tableDiv = maker.addNode("th", tableRow);
1127  maker.addText(tableDiv, "Instantaneous Number of DQMEvents in DQMEvent Queue");
1128  tableDiv = maker.addNode("th", tableRow);
1129  maker.addText(tableDiv, "Memory used in DQMEvent Queue (MB)");
1130  tableDiv = maker.addNode("th", tableRow);
1131  maker.addText(tableDiv, "Number of DQMEvents Popped from DQMEvent Queue (Hz)");
1132  tableDiv = maker.addNode("th", tableRow);
1133  maker.addText(tableDiv, "Data Rate Popped from DQMEvent Queue (MB/sec)");
1134  tableDiv = maker.addNode("th", tableRow);
1135  maker.addText(tableDiv, "DQMEvent Processor Thread Busy Percentage");
1136 
1137  ThroughputMonitorCollection::Stats stats;
1138  tmc.getStats(stats);
1139 
1140  addRowForThroughputStatistics(maker, table, stats.average, true);
1141 
1142  for (ThroughputMonitorCollection::Stats::Snapshots::const_iterator
1143  it = stats.snapshots.begin(),
1144  itEnd = stats.snapshots.end();
1145  it != itEnd;
1146  ++it)
1147  {
1148  addRowForThroughputStatistics(maker, table, (*it));
1149  }
1150 
1151  addRowForThroughputStatistics(maker, table, stats.average, true);
1152  }
1153 
1154 
1155  void SMWebPageHelper::addRowForThroughputStatistics
1156  (
1157  XHTMLMaker& maker,
1158  XHTMLMaker::Node* table,
1159  const ThroughputMonitorCollection::Stats::Snapshot& snapshot,
1160  const bool isAverage
1161  ) const
1162  {
1163  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1164  XHTMLMaker::Node* tableDiv;
1165  XHTMLMaker::AttrMap tableValueAttr = tableValueAttr_;
1166 
1167  if (isAverage)
1168  {
1169  tableValueAttr[ "style" ] = "background-color: yellow;";
1170  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1171  std::ostringstream avg;
1172  avg << "<" << snapshot.duration.total_seconds() << "s>";
1173  maker.addText(tableDiv, avg.str());
1174  }
1175  else
1176  {
1177  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1178  maker.addText( tableDiv, utils::timeStampUTC(snapshot.absoluteTime) );
1179  }
1180 
1181  // memory pool usage
1182  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1183  maker.addDouble( tableDiv, snapshot.poolUsage, 0 );
1184 
1185  // number of fragments in fragment queue
1186  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1187  maker.addDouble( tableDiv, snapshot.entriesInFragmentQueue, 0 );
1188 
1189  // memory used in fragment queue
1190  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1191  maker.addDouble( tableDiv, snapshot.memoryUsedInFragmentQueue, 1 );
1192 
1193  // number of fragments popped from fragment queue
1194  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1195  maker.addDouble( tableDiv, snapshot.fragmentQueueRate, 0 );
1196 
1197  // data rate popped from fragment queue
1198  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1199  maker.addDouble( tableDiv, snapshot.fragmentQueueBandwidth, 1 );
1200 
1201  // fragment processor thread busy percentage
1202  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1203  maker.addDouble( tableDiv, snapshot.fragmentProcessorBusy, 1 );
1204 
1205  // number of events in fragment store
1206  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1207  maker.addDouble( tableDiv, snapshot.fragmentStoreSize, 0 );
1208 
1209  // memory used in fragment store
1210  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1211  maker.addDouble( tableDiv, snapshot.fragmentStoreMemoryUsed, 1 );
1212 
1213  // number of events in stream queue
1214  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1215  maker.addDouble( tableDiv, snapshot.entriesInStreamQueue, 0 );
1216 
1217  // memory used in stream queue
1218  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1219  maker.addDouble( tableDiv, snapshot.memoryUsedInStreamQueue, 1 );
1220 
1221  // number of events popped from stream queue
1222  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1223  maker.addDouble( tableDiv, snapshot.streamQueueRate, 0 );
1224 
1225  // data rate popped from stream queue
1226  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1227  maker.addDouble( tableDiv, snapshot.streamQueueBandwidth, 1 );
1228 
1229  // disk writer thread busy percentage
1230  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1231  maker.addDouble( tableDiv, snapshot.diskWriterBusy, 1 );
1232 
1233  // number of events written to disk
1234  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1235  maker.addDouble( tableDiv, snapshot.writtenEventsRate, 0 );
1236 
1237  // date rate written to disk
1238  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1239  maker.addDouble( tableDiv, snapshot.writtenEventsBandwidth, 1 );
1240 
1241  // number of dqm events in DQMEvent queue
1242  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1243  maker.addDouble( tableDiv, snapshot.entriesInDQMQueue, 0 );
1244 
1245  // memory used in DQMEvent queue
1246  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1247  maker.addDouble( tableDiv, snapshot.memoryUsedInDQMQueue, 1 );
1248 
1249  // number of dqm events popped from DQMEvent queue
1250  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1251  maker.addDouble( tableDiv, snapshot.dqmQueueRate, 0 );
1252 
1253  // data rate popped from DQMEvent queue
1254  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1255  maker.addDouble( tableDiv, snapshot.dqmQueueBandwidth, 1 );
1256 
1257  // DQMEvent processor thread busy percentage
1258  tableDiv = maker.addNode("td", tableRow, tableValueAttr);
1259  maker.addDouble( tableDiv, snapshot.dqmEventProcessorBusy, 1 );
1260  }
1261 
1262 
1263  void SMWebPageHelper::addOutputModuleTables
1264  (
1265  XHTMLMaker& maker,
1266  XHTMLMaker::Node *parent,
1267  DataSenderMonitorCollection const& dsmc
1268  ) const
1269  {
1270  DataSenderMonitorCollection::OutputModuleResultsList resultsList =
1271  dsmc.getTopLevelOutputModuleResults();
1272 
1273  addOutputModuleSummary(maker, parent, resultsList);
1274  addOutputModuleStatistics(maker, parent, resultsList);
1275  }
1276 
1277 
1278  void SMWebPageHelper::addOutputModuleStatistics
1279  (
1280  XHTMLMaker& maker,
1281  XHTMLMaker::Node *parent,
1282  long long uniqueRBID,
1283  DataSenderMonitorCollection const& dsmc
1284  ) const
1285  {
1286  DataSenderMonitorCollection::OutputModuleResultsList resultsList =
1287  dsmc.getOutputModuleResultsForRB(uniqueRBID);
1288 
1289  addOutputModuleStatistics(maker, parent, resultsList);
1290  }
1291 
1292 
1293  void SMWebPageHelper::addOutputModuleStatistics
1294  (
1295  XHTMLMaker& maker,
1296  XHTMLMaker::Node *parent,
1297  DataSenderMonitorCollection::OutputModuleResultsList const& resultsList
1298  ) const
1299  {
1300  XHTMLMaker::AttrMap colspanAttr;
1301  colspanAttr[ "colspan" ] = "7";
1302 
1303  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1304 
1305  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1306  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1307  maker.addText(tableDiv, "Received Data Statistics (by output module)");
1308 
1309  // Header
1310  tableRow = maker.addNode("tr", table, specialRowAttr_);
1311  tableDiv = maker.addNode("th", tableRow);
1312  maker.addText(tableDiv, "Output Module");
1313  tableDiv = maker.addNode("th", tableRow);
1314  maker.addText(tableDiv, "Events");
1315  tableDiv = maker.addNode("th", tableRow);
1316  maker.addText(tableDiv, "Size (MB)");
1317  tableDiv = maker.addNode("th", tableRow);
1318  maker.addText(tableDiv, "Size/Evt (KB)");
1319  tableDiv = maker.addNode("th", tableRow);
1320  maker.addText(tableDiv, "RMS (KB)");
1321  tableDiv = maker.addNode("th", tableRow);
1322  maker.addText(tableDiv, "Min (KB)");
1323  tableDiv = maker.addNode("th", tableRow);
1324  maker.addText(tableDiv, "Max (KB)");
1325 
1326  if (resultsList.empty())
1327  {
1328  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1329  messageAttr[ "align" ] = "center";
1330 
1331  tableRow = maker.addNode("tr", table, rowAttr_);
1332  tableDiv = maker.addNode("td", tableRow, messageAttr);
1333  maker.addText(tableDiv, "No output modules are available yet.");
1334  return;
1335  }
1336  else
1337  {
1338  for (unsigned int idx = 0; idx < resultsList.size(); ++idx)
1339  {
1340  std::string outputModuleLabel = resultsList[idx]->name;
1341 
1342  tableRow = maker.addNode("tr", table, rowAttr_);
1343  tableDiv = maker.addNode("td", tableRow);
1344  maker.addText(tableDiv, outputModuleLabel);
1345  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1346  maker.addInt( tableDiv, resultsList[idx]->eventStats.getSampleCount() );
1347  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1348  maker.addDouble( tableDiv,
1349  resultsList[idx]->eventStats.getValueSum()/(double)0x100000 );
1350  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1351  maker.addDouble( tableDiv,
1352  resultsList[idx]->eventStats.getValueAverage()/(double)0x400 );
1353  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1354  maker.addDouble( tableDiv,
1355  resultsList[idx]->eventStats.getValueRMS()/(double)0x400 );
1356  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1357  maker.addDouble( tableDiv,
1358  resultsList[idx]->eventStats.getValueMin()/(double)0x400 );
1359  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1360  maker.addDouble( tableDiv,
1361  resultsList[idx]->eventStats.getValueMax()/(double)0x400 );
1362  }
1363  }
1364  }
1365 
1366 
1367  void SMWebPageHelper::addOutputModuleSummary
1368  (
1369  XHTMLMaker& maker,
1370  XHTMLMaker::Node *parent,
1371  DataSenderMonitorCollection::OutputModuleResultsList const& resultsList
1372  ) const
1373  {
1374  XHTMLMaker::AttrMap colspanAttr;
1375  colspanAttr[ "colspan" ] = "3";
1376 
1377  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1378 
1379  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1380  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1381  maker.addText(tableDiv, "Output Module Summary");
1382 
1383  // Header
1384  tableRow = maker.addNode("tr", table, specialRowAttr_);
1385  tableDiv = maker.addNode("th", tableRow);
1386  maker.addText(tableDiv, "Name");
1387  tableDiv = maker.addNode("th", tableRow);
1388  maker.addText(tableDiv, "ID");
1389  tableDiv = maker.addNode("th", tableRow);
1390  maker.addText(tableDiv, "Header Size (bytes)");
1391 
1392  if (resultsList.empty())
1393  {
1394  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1395  messageAttr[ "align" ] = "center";
1396 
1397  tableRow = maker.addNode("tr", table, rowAttr_);
1398  tableDiv = maker.addNode("td", tableRow, messageAttr);
1399  maker.addText(tableDiv, "No output modules are available yet.");
1400  return;
1401  }
1402  else
1403  {
1404  for (unsigned int idx = 0; idx < resultsList.size(); ++idx)
1405  {
1406  tableRow = maker.addNode("tr", table, rowAttr_);
1407  tableDiv = maker.addNode("td", tableRow);
1408  maker.addText(tableDiv, resultsList[idx]->name);
1409  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1410  maker.addInt( tableDiv, resultsList[idx]->id );
1411  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1412  maker.addInt( tableDiv, resultsList[idx]->initMsgSize );
1413  }
1414  }
1415  }
1416 
1417 
1418  void SMWebPageHelper::addResourceBrokerList
1419  (
1420  XHTMLMaker& maker,
1421  XHTMLMaker::Node *parent,
1422  DataSenderMonitorCollection const& dsmc
1423  ) const
1424  {
1425  DataSenderMonitorCollection::ResourceBrokerResultsList rbResultsList =
1426  dsmc.getAllResourceBrokerResults();
1427  std::sort(rbResultsList.begin(), rbResultsList.end(), compareRBResultPtrValues);
1428 
1429  XHTMLMaker::AttrMap colspanAttr;
1430  colspanAttr[ "colspan" ] = "15";
1431 
1432  XHTMLMaker::AttrMap tableSuspiciousValueAttr = tableValueAttr_;
1433  tableSuspiciousValueAttr[ "style" ] = "background-color: yellow;";
1434 
1435  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1436 
1437  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1438  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1439  maker.addText(tableDiv, "Data Sender Overview");
1440 
1441  // Header
1442  tableRow = maker.addNode("tr", table, specialRowAttr_);
1443  tableDiv = maker.addNode("th", tableRow);
1444  maker.addText(tableDiv, "Resource Broker URL");
1445  tableDiv = maker.addNode("th", tableRow);
1446  maker.addText(tableDiv, "RB instance");
1447  tableDiv = maker.addNode("th", tableRow);
1448  maker.addText(tableDiv, "RB TID");
1449  tableDiv = maker.addNode("th", tableRow);
1450  maker.addText(tableDiv, "# of FUs");
1451  tableDiv = maker.addNode("th", tableRow);
1452  maker.addText(tableDiv, "# of INIT messages");
1453  tableDiv = maker.addNode("th", tableRow);
1454  maker.addText(tableDiv, "# of events");
1455  tableDiv = maker.addNode("th", tableRow);
1456  maker.addText(tableDiv, "# of error events");
1457  tableDiv = maker.addNode("th", tableRow);
1458  maker.addText(tableDiv, "# of faulty events");
1459  tableDiv = maker.addNode("th", tableRow);
1460  maker.addText(tableDiv, "# of outstanding data discards");
1461  tableDiv = maker.addNode("th", tableRow);
1462  maker.addText(tableDiv, "# of DQM events");
1463  tableDiv = maker.addNode("th", tableRow);
1464  maker.addText(tableDiv, "# of faulty DQM events");
1465  tableDiv = maker.addNode("th", tableRow);
1466  maker.addText(tableDiv, "# of outstanding DQM discards");
1467  tableDiv = maker.addNode("th", tableRow);
1468  maker.addText(tableDiv, "# of ignored discards");
1469  tableDiv = maker.addNode("th", tableRow);
1470  maker.addText(tableDiv, "Recent event rate (Hz)");
1471  tableDiv = maker.addNode("th", tableRow);
1472  maker.addText(tableDiv, "Last event number received");
1473 
1474  if (rbResultsList.empty())
1475  {
1476  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1477  messageAttr[ "align" ] = "center";
1478 
1479  tableRow = maker.addNode("tr", table, rowAttr_);
1480  tableDiv = maker.addNode("td", tableRow, messageAttr);
1481  maker.addText(tableDiv, "No data senders have registered yet.");
1482  return;
1483  }
1484  else
1485  {
1486  for (unsigned int idx = 0; idx < rbResultsList.size(); ++idx)
1487  {
1488  tableRow = maker.addNode("tr", table, rowAttr_);
1489 
1490  tableDiv = maker.addNode("td", tableRow);
1491  XHTMLMaker::AttrMap linkAttr;
1492  linkAttr[ "href" ] = baseURL() + "/rbsenderdetail?id=" +
1493  boost::lexical_cast<std::string>(rbResultsList[idx]->uniqueRBID);
1494  XHTMLMaker::Node* link = maker.addNode("a", tableDiv, linkAttr);
1495  maker.addText(link, rbResultsList[idx]->key.hltURL);
1496 
1497  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1498  maker.addInt( tableDiv, rbResultsList[idx]->key.hltInstance );
1499  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1500  maker.addInt( tableDiv, rbResultsList[idx]->key.hltTid );
1501  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1502  maker.addInt( tableDiv, rbResultsList[idx]->filterUnitCount );
1503  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1504  maker.addInt(tableDiv, rbResultsList[idx]->initMsgCount );
1505  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1506  maker.addInt( tableDiv, rbResultsList[idx]->eventStats.getSampleCount() );
1507  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1508  maker.addInt( tableDiv, rbResultsList[idx]->errorEventStats.getSampleCount() );
1509 
1510  if (rbResultsList[idx]->faultyEventStats.getSampleCount() != 0)
1511  {
1512  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1513  }
1514  else
1515  {
1516  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1517  }
1518  maker.addInt( tableDiv, rbResultsList[idx]->faultyEventStats.getSampleCount() );
1519 
1520  if (rbResultsList[idx]->outstandingDataDiscardCount != 0)
1521  {
1522  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1523  }
1524  else
1525  {
1526  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1527  }
1528  maker.addInt( tableDiv, rbResultsList[idx]->outstandingDataDiscardCount );
1529 
1530  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1531  maker.addInt( tableDiv, rbResultsList[idx]->dqmEventStats.getSampleCount() );
1532 
1533  if (rbResultsList[idx]->faultyDQMEventStats.getSampleCount() != 0)
1534  {
1535  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1536  }
1537  else
1538  {
1539  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1540  }
1541  maker.addInt( tableDiv, rbResultsList[idx]->faultyDQMEventStats.getSampleCount() );
1542 
1543  if (rbResultsList[idx]->outstandingDQMDiscardCount != 0)
1544  {
1545  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1546  }
1547  else
1548  {
1549  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1550  }
1551  maker.addInt( tableDiv, rbResultsList[idx]->outstandingDQMDiscardCount );
1552 
1553  const int skippedDiscards = rbResultsList[idx]->skippedDiscardStats.getSampleCount();
1554  if (skippedDiscards != 0)
1555  {
1556  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1557  }
1558  else
1559  {
1560  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1561  }
1562  maker.addInt( tableDiv, skippedDiscards );
1563 
1564  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1565  maker.addDouble( tableDiv, rbResultsList[idx]->eventStats.
1566  getSampleRate(MonitoredQuantity::RECENT) );
1567  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1568  maker.addInt( tableDiv, rbResultsList[idx]->lastEventNumber );
1569  }
1570  }
1571  }
1572 
1573 
1574  void SMWebPageHelper::addResourceBrokerDetails
1575  (
1576  XHTMLMaker& maker,
1577  XHTMLMaker::Node *parent,
1578  long long uniqueRBID,
1579  DataSenderMonitorCollection const& dsmc
1580  ) const
1581  {
1582  DataSenderMonitorCollection::RBResultPtr rbResultPtr =
1583  dsmc.getOneResourceBrokerResult(uniqueRBID);
1584 
1585  if (rbResultPtr.get() == 0)
1586  {
1587  maker.addText(parent, "The requested resource broker page is not currently available.");
1588  return;
1589  }
1590 
1591  int tmpDuration;
1592  std::string tmpText;
1593 
1594  XHTMLMaker::AttrMap colspanAttr;
1595  colspanAttr[ "colspan" ] = "2";
1596 
1597  XHTMLMaker::AttrMap tableAttr = tableAttr_;
1598  tableAttr[ "width" ] = "";
1599 
1600  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr);
1601 
1602  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1603  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1604  maker.addText(tableDiv, "Resource Broker Details");
1605 
1606  // Header
1607  tableRow = maker.addNode("tr", table, specialRowAttr_);
1608  tableDiv = maker.addNode("th", tableRow);
1609  maker.addText(tableDiv, "Parameter");
1610  tableDiv = maker.addNode("th", tableRow);
1611  maker.addText(tableDiv, "Value");
1612 
1613  tableRow = maker.addNode("tr", table, rowAttr_);
1614  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1615  maker.addText(tableDiv, "URL");
1616  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1617  XHTMLMaker::AttrMap linkAttr;
1618  linkAttr[ "href" ] = rbResultPtr->key.hltURL + "/urn:xdaq-application:lid=" +
1619  boost::lexical_cast<std::string>(rbResultPtr->key.hltLocalId);
1620  XHTMLMaker::Node* link = maker.addNode("a", tableDiv, linkAttr);
1621  maker.addText(link, rbResultPtr->key.hltURL);
1622 
1623  tableRow = maker.addNode("tr", table, rowAttr_);
1624  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1625  maker.addText(tableDiv, "Class Name");
1626  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1627  maker.addText(tableDiv, rbResultPtr->key.hltClassName);
1628 
1629  tableRow = maker.addNode("tr", table, rowAttr_);
1630  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1631  maker.addText(tableDiv, "Instance");
1632  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1633  maker.addInt( tableDiv, rbResultPtr->key.hltInstance );
1634 
1635  tableRow = maker.addNode("tr", table, rowAttr_);
1636  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1637  maker.addText(tableDiv, "Local ID");
1638  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1639  maker.addInt( tableDiv, rbResultPtr->key.hltLocalId );
1640 
1641  tableRow = maker.addNode("tr", table, rowAttr_);
1642  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1643  maker.addText(tableDiv, "Tid");
1644  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1645  maker.addInt( tableDiv, rbResultPtr->key.hltTid );
1646 
1647  tableRow = maker.addNode("tr", table, rowAttr_);
1648  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1649  maker.addText(tableDiv, "INIT Message Count");
1650  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1651  maker.addInt( tableDiv, rbResultPtr->initMsgCount );
1652 
1653  tableRow = maker.addNode("tr", table, rowAttr_);
1654  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1655  maker.addText(tableDiv, "Event Count");
1656  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1657  maker.addInt( tableDiv, rbResultPtr->eventStats.getSampleCount() );
1658 
1659  tableRow = maker.addNode("tr", table, rowAttr_);
1660  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1661  maker.addText(tableDiv, "Error Event Count");
1662  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1663  maker.addInt( tableDiv, rbResultPtr->errorEventStats.getSampleCount() );
1664 
1665  tableRow = maker.addNode("tr", table, rowAttr_);
1666  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1667  maker.addText(tableDiv, "Faulty Event Count");
1668  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1669  maker.addInt( tableDiv, rbResultPtr->faultyEventStats.getSampleCount() );
1670 
1671  tableRow = maker.addNode("tr", table, rowAttr_);
1672  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1673  maker.addText(tableDiv, "Data Discard Count");
1674  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1675  maker.addInt( tableDiv, rbResultPtr->dataDiscardStats.getSampleCount() );
1676 
1677  tableRow = maker.addNode("tr", table, rowAttr_);
1678  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1679  maker.addText(tableDiv, "DQM Event Count");
1680  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1681  maker.addInt( tableDiv, rbResultPtr->dqmEventStats.getSampleCount() );
1682 
1683  tableRow = maker.addNode("tr", table, rowAttr_);
1684  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1685  maker.addText(tableDiv, "Faulty DQM Event Count");
1686  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1687  maker.addInt( tableDiv, rbResultPtr->faultyDQMEventStats.getSampleCount() );
1688 
1689  tableRow = maker.addNode("tr", table, rowAttr_);
1690  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1691  maker.addText(tableDiv, "DQM Discard Count");
1692  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1693  maker.addInt( tableDiv, rbResultPtr->dqmDiscardStats.getSampleCount() );
1694 
1695  tableRow = maker.addNode("tr", table, rowAttr_);
1696  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1697  maker.addText(tableDiv, "Ignored Discards Count");
1698  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1699  maker.addInt( tableDiv, rbResultPtr->skippedDiscardStats.getSampleCount() );
1700 
1701  tableRow = maker.addNode("tr", table, rowAttr_);
1702  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1703  maker.addText(tableDiv, "Last Event Number Received");
1704  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1705  maker.addInt( tableDiv, rbResultPtr->lastEventNumber );
1706 
1707  tableRow = maker.addNode("tr", table, rowAttr_);
1708  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1709  maker.addText(tableDiv, "Last Run Number Received");
1710  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1711  maker.addInt( tableDiv, rbResultPtr->lastRunNumber );
1712 
1713  tableRow = maker.addNode("tr", table, rowAttr_);
1714  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1715  tmpDuration = rbResultPtr->eventStats.recentDuration.total_seconds();
1716  tmpText = "Recent (" + boost::lexical_cast<std::string>(tmpDuration) +
1717  " sec) Event Rate (Hz)";
1718  maker.addText(tableDiv, tmpText);
1719  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1720  maker.addDouble( tableDiv, rbResultPtr->eventStats.recentSampleRate );
1721 
1722  tableRow = maker.addNode("tr", table, rowAttr_);
1723  tableDiv = maker.addNode("td", tableRow, tableLabelAttr_);
1724  tmpDuration = rbResultPtr->eventStats.fullDuration.total_seconds();
1725  tmpText = "Full (" + boost::lexical_cast<std::string>(tmpDuration) +
1726  " sec) Event Rate (Hz)";
1727  maker.addText(tableDiv, tmpText);
1728  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1729  maker.addDouble( tableDiv, rbResultPtr->eventStats.fullSampleRate );
1730  }
1731 
1732 
1733  void SMWebPageHelper::addFilterUnitList
1734  (
1735  XHTMLMaker& maker,
1736  XHTMLMaker::Node *parent,
1737  long long uniqueRBID,
1738  DataSenderMonitorCollection const& dsmc
1739  ) const
1740  {
1741  DataSenderMonitorCollection::FilterUnitResultsList fuResultsList =
1742  dsmc.getFilterUnitResultsForRB(uniqueRBID);
1743 
1744  XHTMLMaker::AttrMap colspanAttr;
1745  colspanAttr[ "colspan" ] = "13";
1746 
1747  XHTMLMaker::AttrMap tableSuspiciousValueAttr = tableValueAttr_;
1748  tableSuspiciousValueAttr[ "style" ] = "background-color: yellow;";
1749 
1750  XHTMLMaker::Node* table = maker.addNode("table", parent, tableAttr_);
1751 
1752  XHTMLMaker::Node* tableRow = maker.addNode("tr", table, rowAttr_);
1753  XHTMLMaker::Node* tableDiv = maker.addNode("th", tableRow, colspanAttr);
1754  maker.addText(tableDiv, "Filter Units");
1755 
1756  // Header
1757  tableRow = maker.addNode("tr", table, specialRowAttr_);
1758  tableDiv = maker.addNode("th", tableRow);
1759  maker.addText(tableDiv, "Process ID");
1760  tableDiv = maker.addNode("th", tableRow);
1761  maker.addText(tableDiv, "# of INIT messages");
1762  tableDiv = maker.addNode("th", tableRow);
1763  maker.addText(tableDiv, "# of events");
1764  tableDiv = maker.addNode("th", tableRow);
1765  maker.addText(tableDiv, "# of error events");
1766  tableDiv = maker.addNode("th", tableRow);
1767  maker.addText(tableDiv, "# of faulty events");
1768  tableDiv = maker.addNode("th", tableRow);
1769  maker.addText(tableDiv, "# of outstanding data discards");
1770  tableDiv = maker.addNode("th", tableRow);
1771  maker.addText(tableDiv, "# of DQM events");
1772  tableDiv = maker.addNode("th", tableRow);
1773  maker.addText(tableDiv, "# of faulty DQM events");
1774  tableDiv = maker.addNode("th", tableRow);
1775  maker.addText(tableDiv, "# of outstanding DQM discards");
1776  tableDiv = maker.addNode("th", tableRow);
1777  maker.addText(tableDiv, "# of ignored discards");
1778  tableDiv = maker.addNode("th", tableRow);
1779  maker.addText(tableDiv, "Recent event rate (Hz)");
1780  tableDiv = maker.addNode("th", tableRow);
1781  maker.addText(tableDiv, "Last event number received");
1782  tableDiv = maker.addNode("th", tableRow);
1783  maker.addText(tableDiv, "Last run number received");
1784 
1785  if (fuResultsList.empty())
1786  {
1787  XHTMLMaker::AttrMap messageAttr = colspanAttr;
1788  messageAttr[ "align" ] = "center";
1789 
1790  tableRow = maker.addNode("tr", table, rowAttr_);
1791  tableDiv = maker.addNode("td", tableRow, messageAttr);
1792  maker.addText(tableDiv, "No filter units have registered yet.");
1793  return;
1794  }
1795  else
1796  {
1797  for (unsigned int idx = 0; idx < fuResultsList.size(); ++idx)
1798  {
1799  tableRow = maker.addNode("tr", table, rowAttr_);
1800 
1801  tableDiv = maker.addNode("td", tableRow);
1802  maker.addInt( tableDiv, fuResultsList[idx]->key.fuProcessId );
1803  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1804  maker.addInt( tableDiv, fuResultsList[idx]->initMsgCount );
1805  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1806  maker.addInt( tableDiv, fuResultsList[idx]->shortIntervalEventStats.getSampleCount() );
1807  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1808  maker.addInt( tableDiv, fuResultsList[idx]->errorEventStats.getSampleCount() );
1809 
1810  if (fuResultsList[idx]->faultyEventStats.getSampleCount() != 0)
1811  {
1812  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1813  }
1814  else
1815  {
1816  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1817  }
1818  maker.addInt( tableDiv, fuResultsList[idx]->faultyEventStats.getSampleCount() );
1819 
1820  if (fuResultsList[idx]->outstandingDataDiscardCount != 0)
1821  {
1822  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1823  }
1824  else
1825  {
1826  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1827  }
1828  maker.addInt( tableDiv, fuResultsList[idx]->outstandingDataDiscardCount );
1829 
1830  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1831  maker.addInt( tableDiv, fuResultsList[idx]->dqmEventStats.getSampleCount() );
1832 
1833  if (fuResultsList[idx]->faultyDQMEventStats.getSampleCount() != 0)
1834  {
1835  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1836  }
1837  else
1838  {
1839  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1840  }
1841  maker.addInt( tableDiv, fuResultsList[idx]->faultyDQMEventStats.getSampleCount() );
1842 
1843  if (fuResultsList[idx]->outstandingDQMDiscardCount != 0)
1844  {
1845  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1846  }
1847  else
1848  {
1849  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1850  }
1851  maker.addInt( tableDiv, fuResultsList[idx]->outstandingDQMDiscardCount );
1852 
1853  const int skippedDiscards = fuResultsList[idx]->skippedDiscardStats.getSampleCount();
1854  if (skippedDiscards != 0)
1855  {
1856  tableDiv = maker.addNode("td", tableRow, tableSuspiciousValueAttr);
1857  }
1858  else
1859  {
1860  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1861  }
1862  maker.addInt( tableDiv, skippedDiscards );
1863 
1864  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1865  maker.addDouble( tableDiv, fuResultsList[idx]->shortIntervalEventStats.
1866  getSampleRate(MonitoredQuantity::RECENT) );
1867  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1868  maker.addInt( tableDiv, fuResultsList[idx]->lastEventNumber );
1869  tableDiv = maker.addNode("td", tableRow, tableValueAttr_);
1870  maker.addInt( tableDiv, fuResultsList[idx]->lastRunNumber );
1871  }
1872  }
1873  }
1874 
1875 } // namespace stor
1876 
1877 
stor::MonitoredQuantity::Stats::getValueRate
double getValueRate(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:244
asciidump.table
list table
Definition: asciidump.py:386
stor::SMWebPageHelper::addOutputModuleTables
void addOutputModuleTables(XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection const &) const
Definition: SMWebPageHelper.cc:1264
stor::XHTMLMaker::addNode
Node * addNode(const std::string &name, Node *parent, const AttrMap &attrs)
Definition: XHTMLMaker.cc:146
stor::WebPageHelper< SMWebPageHelper >::addDOMforDQMEventStatistics
void addDOMforDQMEventStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, DQMEventMonitorCollection const &) const
stor::XHTMLMaker::addDouble
void addDouble(Node *parent, const double &value, const unsigned int &precision=2)
Definition: XHTMLMaker.cc:244
stor::SMWebPageHelper::addOutputModuleSummary
void addOutputModuleSummary(XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection::OutputModuleResultsList const &) const
Definition: SMWebPageHelper.cc:1368
stor::RunMonitorCollection::getLumiSectionsSeenMQ
const MonitoredQuantity & getLumiSectionsSeenMQ() const
Definition: RunMonitorCollection.h:69
stor::SMWebPageHelper::dqmEventWebPage
void dqmEventWebPage(xgi::Output *) const
Definition: SMWebPageHelper.cc:201
stor::DataSenderMonitorCollection::getTopLevelOutputModuleResults
OutputModuleResultsList getTopLevelOutputModuleResults() const
Definition: DataSenderMonitorCollection.cc:321
dbtoconf.parent
list parent
Definition: dbtoconf.py:74
stor::SMWebPageHelper::throughputWebPage
void throughputWebPage(xgi::Output *) const
Definition: SMWebPageHelper.cc:222
stor::SMWebPageHelper::consumerWebPageHelper_
ConsumerWebPageHelper_t consumerWebPageHelper_
Definition: SMWebPageHelper.h:432
stor::DataSenderMonitorCollection::getOneResourceBrokerResult
RBResultPtr getOneResourceBrokerResult(UniqueResourceBrokerID_t) const
Definition: DataSenderMonitorCollection.cc:351
stor::XHTMLMaker::addText
void addText(Node *parent, const std::string &)
Definition: XHTMLMaker.cc:173
stor::SMWebPageHelper::resourceBrokerOverview
void resourceBrokerOverview(xgi::Output *) const
Definition: SMWebPageHelper.cc:142
stor::SMWebPageHelper::addTableForResourceUsages
void addTableForResourceUsages(XHTMLMaker &maker, XHTMLMaker::Node *parent, ResourceMonitorCollection::Stats const &, MonitoredQuantity::Stats const &) const
Definition: SMWebPageHelper.cc:349
stor::utils::timeStampUTC
std::string timeStampUTC(TimePoint_t)
Definition: Utils.cc:38
stor::RunMonitorCollection::getUnwantedEventIDsReceivedMQ
const MonitoredQuantity & getUnwantedEventIDsReceivedMQ() const
Definition: RunMonitorCollection.h:55
stor::SMWebPageHelper::addRowForFramesReceived
void addRowForFramesReceived(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:596
stor::MonitoredQuantity::Stats::getSampleCount
uint64_t getSampleCount(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:241
stor::SMWebPageHelper::addOutputModuleStatistics
void addOutputModuleStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
Definition: SMWebPageHelper.cc:1279
stor::SMWebPageHelper::addRowForLatency
void addRowForLatency(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:656
stor::SMWebPageHelper::addRowForThroughputStatistics
void addRowForThroughputStatistics(XHTMLMaker &maker, XHTMLMaker::Node *table, const ThroughputMonitorCollection::Stats::Snapshot &, bool const isAverage=false) const
Definition: SMWebPageHelper.cc:1156
stor::RunMonitorCollection::getErrorEventIDsReceivedMQ
const MonitoredQuantity & getErrorEventIDsReceivedMQ() const
Definition: RunMonitorCollection.h:48
stor::SMWebPageHelper::addRowsForWorkers
void addRowsForWorkers(XHTMLMaker &maker, XHTMLMaker::Node *table, ResourceMonitorCollection::Stats const &) const
Definition: SMWebPageHelper.cc:405
stor::SharedResourcesPtr
boost::shared_ptr< SharedResources > SharedResourcesPtr
Definition: SharedResources.h:74
stor::MonitoredQuantity::getStats
void getStats(Stats &stats) const
Definition: MonitoredQuantity.cc:343
stor::MonitoredQuantity::Stats::getValueMin
double getValueMin(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:246
stor::SMWebPageHelper::createWebPageBody
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const StateMachineMonitorCollection &) const
Definition: SMWebPageHelper.cc:243
stor::StatisticsReporterPtr
boost::shared_ptr< StatisticsReporter > StatisticsReporterPtr
Definition: StatisticsReporter.h:211
stor::SMWebPageHelper::addDOMforHyperLinks
void addDOMforHyperLinks(XHTMLMaker &, XHTMLMaker::Node *parent) const
Definition: SMWebPageHelper.cc:263
stor::SMWebPageHelper::addDOMforFiles
void addDOMforFiles(XHTMLMaker &maker, XHTMLMaker::Node *parent, FilesMonitorCollection const &) const
Definition: SMWebPageHelper.cc:1005
AlCaRecoCosmics_cfg.name
tuple name
Definition: AlCaRecoCosmics_cfg.py:24
stor::StreamsMonitorCollection::getAllStreamsBandwidthMQ
const MonitoredQuantity & getAllStreamsBandwidthMQ() const
Definition: StreamsMonitorCollection.h:103
link
std::string link(std::string &nm, std::string &ns)
Definition: hierarchy.cc:47
stor::SMWebPageHelper::SMWebPageHelper
SMWebPageHelper(xdaq::ApplicationDescriptor *, SharedResourcesPtr)
Definition: SMWebPageHelper.cc:38
stor::DataSenderMonitorCollection::getFilterUnitResultsForRB
FilterUnitResultsList getFilterUnitResultsForRB(UniqueResourceBrokerID_t uniqueRBID) const
Definition: DataSenderMonitorCollection.cc:388
stor::MonitoredQuantity::Stats::getDuration
utils::Duration_t getDuration(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:248
stor::StreamsMonitorCollection::StreamRecordList
std::vector< StreamRecordPtr > StreamRecordList
Definition: StreamsMonitorCollection.h:78
stor::SMWebPageHelper::addRowForMinBandwidth
void addRowForMinBandwidth(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:716
stor::FragmentMonitorCollection::getStats
void getStats(FragmentStats &stats) const
Definition: FragmentMonitorCollection.cc:48
maker
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:58
stor::SMWebPageHelper::addFilterUnitList
void addFilterUnitList(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
Definition: SMWebPageHelper.cc:1734
stor::FilesMonitorCollection::getFileRecords
void getFileRecords(FileRecordList &) const
Definition: FilesMonitorCollection.cc:37
stor::XHTMLMaker::AttrMap
std::map< std::string, std::string > AttrMap
Definition: XHTMLMaker.h:36
stor::StreamsMonitorCollection::getAllStreamsVolumeMQ
const MonitoredQuantity & getAllStreamsVolumeMQ() const
Definition: StreamsMonitorCollection.h:96
stor::SMWebPageHelper::addDOMforFragmentMonitor
void addDOMforFragmentMonitor(XHTMLMaker &maker, XHTMLMaker::Node *parent, FragmentMonitorCollection const &) const
Definition: SMWebPageHelper.cc:521
stor::SMWebPageHelper::resourceBrokerDetail
void resourceBrokerDetail(xgi::Output *, const long long &uniqueRBID) const
Definition: SMWebPageHelper.cc:169
stor::SMWebPageHelper::addDOMforStoredData
void addDOMforStoredData(XHTMLMaker &maker, XHTMLMaker::Node *parent, StreamsMonitorCollection const &) const
Definition: SMWebPageHelper.cc:815
stor::XHTMLMaker::addInt
void addInt(Node *parent, const int &)
Definition: XHTMLMaker.cc:184
stor::MonitoredQuantity::Stats::getSampleRate
double getSampleRate(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:249
stor::RunMonitorCollection::getEoLSSeenMQ
const MonitoredQuantity & getEoLSSeenMQ() const
Definition: RunMonitorCollection.h:76
stor::SMWebPageHelper::storedDataWebPage
void storedDataWebPage(xgi::Output *) const
Definition: SMWebPageHelper.cc:78
stor::WebPageHelper< SMWebPageHelper >::addDOMforProcessedDQMEvents
void addDOMforProcessedDQMEvents(XHTMLMaker &maker, XHTMLMaker::Node *parent, DQMEventMonitorCollection const &) const
stor::SMWebPageHelper::addDOMforResourceUsage
void addDOMforResourceUsage(XHTMLMaker &, XHTMLMaker::Node *parent, ResourceMonitorCollection const &, ThroughputMonitorCollection const &) const
Definition: SMWebPageHelper.cc:321
stor::StateMachineMonitorCollection::externallyVisibleState
const std::string & externallyVisibleState() const
Definition: StateMachineMonitorCollection.cc:55
stor::SMWebPageHelper::addRowForTotalVolume
void addRowForTotalVolume(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:676
stor::SMWebPageHelper::addTableForDiskUsages
void addTableForDiskUsages(XHTMLMaker &maker, XHTMLMaker::Node *parent, ResourceMonitorCollection::Stats const &) const
Definition: SMWebPageHelper.cc:469
dbtoconf.out
tuple out
Definition: dbtoconf.py:99
stor::DataSenderMonitorCollection::OutputModuleResultsList
std::vector< boost::shared_ptr< OutputModuleResult > > OutputModuleResultsList
Definition: DataSenderMonitorCollection.h:224
stor::SMWebPageHelper::addDOMforThroughputStatistics
void addDOMforThroughputStatistics(XHTMLMaker &maker, XHTMLMaker::Node *parent, ThroughputMonitorCollection const &) const
Definition: SMWebPageHelper.cc:1077
stor::RunMonitorCollection::getEventIDsReceivedMQ
const MonitoredQuantity & getEventIDsReceivedMQ() const
Definition: RunMonitorCollection.h:41
stor::DataSenderMonitorCollection::ResourceBrokerResultsList
std::vector< RBResultPtr > ResourceBrokerResultsList
Definition: DataSenderMonitorCollection.h:260
stor::MonitoredQuantity::Stats::getValueMax
double getValueMax(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:247
stor::SMWebPageHelper::addResourceBrokerDetails
void addResourceBrokerDetails(XHTMLMaker &maker, XHTMLMaker::Node *parent, long long uniqueRBID, DataSenderMonitorCollection const &) const
Definition: SMWebPageHelper.cc:1575
stor::SMWebPageHelper::addRowsForSataBeast
void addRowsForSataBeast(XHTMLMaker &maker, XHTMLMaker::Node *table, ResourceMonitorCollection::Stats const &) const
Definition: SMWebPageHelper.cc:431
stor::SMWebPageHelper::sharedResources_
SharedResourcesPtr sharedResources_
Definition: SMWebPageHelper.h:427
stor::SMWebPageHelper::addRowsForMemoryUsage
void addRowsForMemoryUsage(XHTMLMaker &maker, XHTMLMaker::Node *table, MonitoredQuantity::Stats const &) const
Definition: SMWebPageHelper.cc:371
stor::SMWebPageHelper::addRowForBandwidth
void addRowForBandwidth(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:616
stor::DataSenderMonitorCollection::RBResultPtr
boost::shared_ptr< ResourceBrokerResult > RBResultPtr
Definition: DataSenderMonitorCollection.h:259
stor::SMWebPageHelper::listStreamRecordsStats
void listStreamRecordsStats(XHTMLMaker &maker, XHTMLMaker::Node *table, StreamsMonitorCollection const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:925
stor::SMWebPageHelper::addRowForRate
void addRowForRate(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:636
stor::SMWebPageHelper::filesWebPage
void filesWebPage(xgi::Output *) const
Definition: SMWebPageHelper.cc:102
combine.key
list key
Definition: combine.py:13
stor::SMWebPageHelper::addResourceBrokerList
void addResourceBrokerList(XHTMLMaker &maker, XHTMLMaker::Node *parent, DataSenderMonitorCollection const &) const
Definition: SMWebPageHelper.cc:1419
Output
#define Output(cl)
Definition: vmac.h:193
stor::StreamsMonitorCollection::getStreamRecords
void getStreamRecords(StreamRecordList &) const
Definition: StreamsMonitorCollection.cc:40
stor::ConsumerWebPageHelper::consumerStatistics
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
stor::SMWebPageHelper::addFragmentStats
void addFragmentStats(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:557
stor::compareRBResultPtrValues
bool compareRBResultPtrValues(DataSenderMonitorCollection::RBResultPtr firstValue, DataSenderMonitorCollection::RBResultPtr secondValue)
Definition: DataSenderMonitorCollection.cc:852
stor::SMWebPageHelper::addDOMforConfigString
void addDOMforConfigString(XHTMLMaker &maker, XHTMLMaker::Node *parent, DiskWritingParams const &) const
Definition: SMWebPageHelper.cc:901
stor::DataSenderMonitorCollection::getAllResourceBrokerResults
ResourceBrokerResultsList getAllResourceBrokerResults() const
Definition: DataSenderMonitorCollection.cc:330
stor::FilesMonitorCollection::FileRecordList
boost::circular_buffer< FileRecordPtr > FileRecordList
Definition: FilesMonitorCollection.h:77
stor::XHTMLMaker::Node
xercesc::DOMElement Node
Definition: XHTMLMaker.h:35
stor::SMWebPageHelper::addRowForMaxBandwidth
void addRowForMaxBandwidth(XHTMLMaker &maker, XHTMLMaker::Node *table, FragmentMonitorCollection::FragmentStats const &, const MonitoredQuantity::DataSetType) const
Definition: SMWebPageHelper.cc:696
stor::StreamsMonitorCollection::getAllStreamsFileCountMQ
const MonitoredQuantity & getAllStreamsFileCountMQ() const
Definition: StreamsMonitorCollection.h:89
stor::ThroughputMonitorCollection::getPoolUsageMQ
const MonitoredQuantity & getPoolUsageMQ() const
Definition: ThroughputMonitorCollection.h:53
stor::DataSenderMonitorCollection::getOutputModuleResultsForRB
OutputModuleResultsList getOutputModuleResultsForRB(UniqueResourceBrokerID_t uniqueRBID) const
Definition: DataSenderMonitorCollection.cc:370
stor::SMWebPageHelper::consumerStatistics
void consumerStatistics(xgi::Output *) const
Definition: SMWebPageHelper.cc:122
stor::WebPageHelper::createWebPageBody
XHTMLMaker::Node * createWebPageBody(XHTMLMaker &, const std::string &pageTitle, const std::string &externallyVisibleState, const std::string &innerStateName, const std::string &errorMsg) const
stor::DiskWritingParams::streamConfiguration_
std::string streamConfiguration_
Definition: Configuration.h:32
stor::MonitoredQuantity::Stats::getValueSum
double getValueSum(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:242
stor::DataSenderMonitorCollection::FilterUnitResultsList
std::vector< FUResultPtr > FilterUnitResultsList
Definition: DataSenderMonitorCollection.h:288
stor::MonitoredQuantity::Stats::getSampleLatency
double getSampleLatency(DataSetType t=FULL) const
Definition: MonitoredQuantity.h:250
stor::RunMonitorCollection::getRunNumbersSeenMQ
const MonitoredQuantity & getRunNumbersSeenMQ() const
Definition: RunMonitorCollection.h:62
fmc
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
stor::SMWebPageHelper::defaultWebPage
void defaultWebPage(xgi::Output *) const
Definition: SMWebPageHelper.cc:48
stor::SMWebPageHelper::addDOMforRunMonitor
void addDOMforRunMonitor(XHTMLMaker &maker, XHTMLMaker::Node *parent, RunMonitorCollection const &) const
Definition: SMWebPageHelper.cc:736
Generated for CMSSW Reference Manual by doxygen 1.8.5