sPhenix code displayed by LXR master/​OnlMon/​onlmonclient/​OnlMonClient.cc	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-08-03 08:20:55

 #include "OnlMonClient.h"
 #include "ClientHistoList.h"
 #include "OnlMonDraw.h"
 #include "OnlMonHtml.h"
 
 #include <onlmon/HistoBinDefs.h>
 #include <onlmon/OnlMonBase.h>  // for OnlMonBase
 #include <onlmon/OnlMonDefs.h>
 
 #include <MessageTypes.h>  // for kMESS_STRING, kMESS_OBJECT
 #include <TCanvas.h>
 #include <TDirectory.h>
 #include <TFile.h>
 #include <TGClient.h>  // for gClient, TGClient
 #include <TGFrame.h>
 #include <TH1.h>
 #include <TImage.h>
 #include <TIterator.h>
 #include <TList.h>  // for TList
 #include <TMessage.h>
 #include <TROOT.h>
 #include <TSeqCollection.h>
 #include <TSocket.h>
 #include <TStyle.h>
 #include <TSystem.h>
 
 #include <odbc++/connection.h>
 #include <odbc++/drivermanager.h>
 #include <odbc++/resultset.h>
 #include <odbc++/statement.h>  // for Statement
 #include <odbc++/types.h>      // for SQLException
 
 #include <sys/stat.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 #include <uuid/uuid.h>
 #include <algorithm>
 #include <cstdio>   // for printf, remove
 #include <cstdlib>  // for getenv, exit
 #include <cstring>  // for strcmp
 #include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <list>
 #include <sstream>
 #include <utility>  // for pair
 
 OnlMonClient *OnlMonClient::__instance = nullptr;
 
 int pinit()
 {
   return 0;
 }
 
 OnlMonClient *OnlMonClient::instance()
 {
   if (__instance)
   {
     return __instance;
   }
   __instance = new OnlMonClient("ONLMONCLIENT");
   return __instance;
 }
 
 OnlMonClient::OnlMonClient(const std::string &name)
   : OnlMonBase(name)
 {
   defaultStyle = new TStyle();
   SetStyleToDefault();
   InitAll();
 }
 
 void OnlMonClient::InitAll()
 {
   if (gROOT->FindObject("ServerRunning"))
   {
     std::cout << "Don't run Server and Client in same session, exiting" << std::endl;
     exit(1);
   }
   if (!gClient)  // cannot draw on display, warn and bail out
   {
     const char *env_display = getenv("DISPLAY");
     if (env_display)
     {
       std::string displaystring = env_display;
       std::cout << "Cannot open Display, Display Env Var is set to "
                 << displaystring << std::endl;
       if (displaystring.find("unix") != std::string::npos)
       {
         utsname ThisNode{};
         uname(&ThisNode);
         std::cout << "presumably the virtual framebuffer is not running on " << ThisNode.nodename
                   << ", check if process /usr/X11R6/bin/Xvfb is alive" << std::endl;
       }
       else if (displaystring.find("localhost") != std::string::npos)
       {
         std::cout << "Check your ssh forwarding" << std::endl;
         std::cout << "your $HOME/.ssh/config has to contain the line" << std::endl;
         std::cout << "ForwardX11 yes" << std::endl;
       }
     }
     else
     {
       std::cout << "Display not set, cannot continue" << std::endl;
     }
     exit(1);
   }
   // we have a working display
   clientrunning = new TH1F("ClientRunning", "ClientRunning", 1, 0, 1);
   if (getenv("ONLMON_HTMLDIR") == nullptr)
   {
     std::cout << "ONLMON_HTMLDIR not set, exiting" << std::endl;
     exit(1);
   }
   fHtml = new OnlMonHtml(getenv("ONLMON_HTMLDIR"));
 
   TGFrame *rootWin = (TGFrame *) gClient->GetRoot();
   display_sizex = rootWin->GetDefaultWidth();
   display_sizey = rootWin->GetDefaultHeight();
   for (int i = 0; i < kMAXSIGNALS; i++)
   {
     gSystem->IgnoreSignal((ESignals) i);
   }
   return;
 }
 
 OnlMonClient::~OnlMonClient()
 {
   while (DrawerList.begin() != DrawerList.end())
   {
     if (verbosity > 0)
     {
       std::cout << "deleting " << DrawerList.begin()->first << std::endl;
     }
     delete DrawerList.begin()->second;
     DrawerList.erase(DrawerList.begin());
   }
   while (Histo.begin() != Histo.end())
   {
     delete Histo.begin()->second;
     Histo.erase(Histo.begin());
   }
   delete clientrunning;
   delete fHtml;
   delete defaultStyle;
   // this deletes all open canvases
   TSeqCollection *allCanvases = gROOT->GetListOfCanvases();
   TCanvas *canvas = nullptr;
   while ((canvas = static_cast<TCanvas *>(allCanvases->First())))
   {
     if (verbosity > 0)
     {
       std::cout << "Deleting Canvas " << canvas->GetName() << std::endl;
     }
     delete canvas;
   }
   __instance = nullptr;
   return;
 }
 
 void OnlMonClient::registerHisto(const std::string &hname, const std::string &subsys)
 {
   auto subsysiter = SubsysHisto.find(subsys);
   if (subsysiter == SubsysHisto.end())
   {
     std::map<const std::string, ClientHistoList *> entry;
     // c++11 map.insert returns pair<iterator,bool>
     subsysiter = SubsysHisto.insert(std::make_pair(subsys, entry)).first;
     if (Verbosity() > 2)
     {
       std::cout << "inserting " << subsys << " into SubsysHisto, readback: " << subsysiter->first << std::endl;
     }
   }
   auto hiter = subsysiter->second.find(hname);
   if (hiter == subsysiter->second.end())
   {
     ClientHistoList *newhisto = new ClientHistoList();
     newhisto->SubSystem(subsys);
     subsysiter->second.insert(std::make_pair(hname, newhisto));
     if (Verbosity() > 0)
     {
       std::cout << "new histogram " << hname << " of subsystem " << subsys << std::endl;
     }
   }
   else
   {
     hiter->second->SubSystem(subsys);
   }
   // register FrameWorkVars histo if we don't have it already
   std::string frameworkhistoname = "FrameWorkVars";
   hiter = subsysiter->second.find(frameworkhistoname);
   if (hiter == subsysiter->second.end())
   {
     ClientHistoList *newhisto = new ClientHistoList();
     newhisto->SubSystem(subsys);
     subsysiter->second.insert(std::make_pair(frameworkhistoname, newhisto));
     if (Verbosity() > 0)
     {
       std::cout << "new histogram " << frameworkhistoname << " of subsystem " << subsys << std::endl;
     }
   }
   else
   {
     hiter->second->SubSystem(subsys);
   }
 
   return;
 }
 
 int OnlMonClient::requestHistoBySubSystem(const std::string &subsys, int getall)
 {
   std::string mysubsys = subsys.substr(0, subsys.find('_'));
   for (const auto &frwrkiter : m_MonitorFetchedSet)
   {
     if (frwrkiter.find(mysubsys) == std::string::npos)
     {
       m_MonitorFetchedSet.clear();
       break;
     }
   }
   int iret = 0;
   std::map<const std::string, ClientHistoList *>::const_iterator histoiter;
   std::map<const std::string, ClientHistoList *>::const_iterator histonewiter;
   if (!IsMonitorRunning(subsys))  // test if saved monitor server is still running
   {
     // monitor is not running - remove its entry if it exists
     auto moniiter = MonitorHostPorts.find(subsys);
     if (moniiter != MonitorHostPorts.end())
     {
       MonitorHostPorts.erase(moniiter);
     }
     // Find monitor, if not found reset ClientHistoList entries for host and port
     if (FindMonitor(subsys) == 0)
     {
       auto subsyshistos = SubsysHisto.find(subsys);
       if (subsyshistos != SubsysHisto.end())
       {
         for (auto &hiter : subsyshistos->second)
         {
           hiter.second->ServerHost("UNKNOWN");
           hiter.second->ServerPort(0);
           if (hiter.second->Histo() != nullptr)
           {
             hiter.second->Histo()->Delete();
           }
           hiter.second->Histo(nullptr);
         }
       }
       return iret;
     }
   }
 
   if (getall == 0)
   {
     std::map<std::string, std::map<const std::string, ClientHistoList *>>::const_iterator histos = SubsysHisto.find(subsys);
     for (auto &hiter : histos->second)
     {
       if (requestHistoByName(subsys, hiter.first))
       {
         if (Verbosity() > 2)
         {
           std::cout << "Request for " << hiter.first << " on " << subsys << " failed " << std::endl;
         }
         if (hiter.second->Histo())
         {
           hiter.second->Histo()->Delete();
           hiter.second->Histo(nullptr);
           hiter.second->ServerHost("UNKNOWN");
           hiter.second->ServerPort(0);
         }
         iret = -1;
       }
     }
   }
   else if (getall == 1)
   {
     std::map<std::string, std::list<std::string>> transferlist;
     std::ostringstream host_port;
 
     int failed_to_locate = 0;
     auto subs = SubsysHisto.find(subsys);
     {
       for (auto &histos : subs->second)
       {
         if (Verbosity() > 2)
         {
           std::cout << "checking for subsystem " << subs->first << ", histo " << histos.first << std::endl;
         }
         if (histos.second->SubSystem() == subsys)
         {
           int unknown_histo = 0;
           std::string hname = histos.first;
           if (histos.second->ServerHost() == "UNKNOWN")
           {
             if (!failed_to_locate)
             {
           //          std::cout << "Looking for " << hname << ", server " << subsys << std::endl;
               if (LocateHistogram(hname, subsys) < 1)
               {
                 if (Verbosity() > 2)
                 {
                   std::cout << "Subsystem " << subsys << " Histogram " << hname << " cannot be located" << std::endl;
                 }
                 failed_to_locate = 1;
                 unknown_histo = 1;
                 iret = -1;
               }
             }
             else
             {
               unknown_histo = 1;
             }
           }
           // reset histogram in case they don't exist on the server anymore
           if (histos.second->Histo())
           {
             histos.second->Histo()->Reset();
           }
           if (!unknown_histo)
           {
             std::string fullhname = subsys + std::string(" ") + hname;
             (transferlist[subsys]).push_back(fullhname);
           }
         }
       }
     }
     std::list<std::string>::const_iterator liter;
     for (auto &listiter : transferlist)
     {
       std::list<std::string> hlist = listiter.second;
       auto hostportiter = MonitorHostPorts.find(listiter.first);
       if (hostportiter == MonitorHostPorts.end())
       {
         std::cout << __PRETTY_FUNCTION__ << "Cannot find MonitorHostPorts entry for " << listiter.first << std::endl;
         std::cout << "existing hosts: " << std::endl;
         for (auto &hport : MonitorHostPorts)
         {
           std::cout << "subsystem " << hport.first << " on host " << hport.second.first
                     << " listening on port " << hport.second.second << std::endl;
         }
         continue;
       }
       if (requestHistoList(listiter.first, hostportiter->second.first, hostportiter->second.second, hlist) != 0)
       {
         for (liter = hlist.begin(); liter != hlist.end(); ++liter)
         {
           if (requestHistoByName(*liter))
           {
             std::cout << "Request for " << *liter << " failed " << std::endl;
             histoiter = Histo.find(*liter);
             if (histoiter->second && histoiter->second->Histo())
             {
               histoiter->second->Histo()->Delete();
               histoiter->second->Histo(nullptr);
               histoiter->second->ServerHost("UNKNOWN");
               histoiter->second->ServerPort(0);
             }
           }
         }
       }
     }
   }
   else if (getall == 2)
   {
     const char *hname = "none";
     for (histoiter = Histo.begin(); histoiter != Histo.end(); ++histoiter)
     {
       if (histoiter->second->SubSystem() == subsys)
       {
         hname = histoiter->first.c_str();
         break;
       }
     }
     // histoiter points here to first histogram of subsystem
     if (histoiter != Histo.end())
     {
       std::string hostname = histoiter->second->ServerHost();
       int moniport = histoiter->second->ServerPort();
       {
         if (hostname == "UNKNOWN")
         {
           if (LocateHistogram(hname, "") < 1)
           {
             std::cout << "Histogram " << hname << " cannot be located" << std::endl;
             return -1;
           }
           histonewiter = Histo.find(hname);
           hostname = histonewiter->second->ServerHost();
           moniport = histonewiter->second->ServerPort();
         }
 
         // Reset the histograms in case they don't exhist on the host.
         for (histonewiter = Histo.begin(); histonewiter != Histo.end(); ++histonewiter)
         {
           if (histonewiter->second->SubSystem() == subsys)
           {
             if (histonewiter->second->Histo())
             {
               histonewiter->second->Histo()->Reset();
             }
           }
         }
 
         if (requestHisto("ALL", hostname, moniport))
         {
           std::cout << "Request for all histograms from "
                     << hostname << " failed, trying single " << std::endl;
           iret = requestHistoBySubSystem(subsys, 0);
         }
       }
     }
     else
     {
       std::cout << "No Histogram of subsystem "
                 << subsys << " registered" << std::endl;
     }
   }
   m_MonitorFetchedSet.insert(subsys);
   return iret;
 }
 
 void OnlMonClient::registerDrawer(OnlMonDraw *Drawer)
 {
   std::map<const std::string, OnlMonDraw *>::iterator iter = DrawerList.find(Drawer->Name());
   if (iter != DrawerList.end())
   {
     std::cout << "Drawer " << Drawer->Name() << " already registered, I won't overwrite it" << std::endl;
     std::cout << "Use a different name and try again" << std::endl;
   }
   else
   {
     DrawerList[Drawer->Name()] = Drawer;
     Drawer->Init();
     SetStyleToDefault();
   }
   return;
 }
 
 int OnlMonClient::Draw(const char *who, const char *what)
 {
   GetServerInfo();
   int iret = DoSomething(who, what, "DRAW");
   //  gSystem->ProcessEvents();
   return iret;
 }
 
 int OnlMonClient::SavePlot(const std::string &who, const std::string &what)
 {
   int iret = DoSomething(who, what, "SAVEPLOT");
   TSeqCollection *allCanvases = gROOT->GetListOfCanvases();
   TCanvas *canvas = nullptr;
   while ((canvas = static_cast<TCanvas *>(allCanvases->First())))
   {
     if (verbosity > 0)
     {
       std::cout << "Deleting Canvas " << canvas->GetName() << std::endl;
     }
     delete canvas;
   }
   //  gSystem->ProcessEvents();
   return iret;
 }
 
 int OnlMonClient::MakePS(const char *who, const char *what)
 {
   int iret = DoSomething(who, what, "PS");
   //  gSystem->ProcessEvents();
   return iret;
 }
 
 int OnlMonClient::MakeHtml(const char *who, const char *what)
 {
   isHtml(true); // so the client knows we run in html mode
   GetServerInfo();
   mode_t old_umask;
   int runno = RunNumber();
   if (runno <= 0)
   {
     std::cout << "Run Number too small: " << runno
               << " not creating html output" << std::endl;
     return 0;
   }
   char *onlmon_real_html = getenv("ONLMON_REAL_HTML");
   if (!onlmon_real_html)
   {
     old_umask = umask(S_IWOTH);
     std::cout << "Making html output group writable so others can run tests as well" << std::endl;
   }
   fHtml->runNumber(runno);  // do not forget this !
   int iret = DoSomething(who, what, "HTML");
 
   if (!onlmon_real_html)
   {
     umask(old_umask);
   }
   //  gSystem->ProcessEvents();
   return iret;
 }
 
 int OnlMonClient::DoSomething(const std::string &who, const std::string &what, const std::string &opt)
 {
   std::map<const std::string, OnlMonDraw *>::iterator iter;
   if (who != "ALL")  // is drawer was specified (!All)
   {
     iter = DrawerList.find(who);
     if (iter != DrawerList.end())
     {
       if (opt == "DRAW")
       {
         iter->second->Draw(what);
       }
       else if (opt == "PS")
       {
         iter->second->MakePS(what);
       }
       else if (opt == "SAVEPLOT")
       {
         iter->second->SavePlot(what, "png");
       }
       else if (opt == "HTML")
       {
         if (verbosity > 0)
         {
           std::cout << __PRETTY_FUNCTION__ << " creating html output for "
                     << iter->second->Name() << std::endl;
         }
         iter->second->isHtml(true);
         if (iter->second->MakeHtml(what))
         {
           std::cout << "subsystem " << iter->second->Name()
                     << " not in root file, skipping" << std::endl;
         }
       }
       else
       {
         std::cout << "option " << opt << " not implemented" << std::endl;
         return 0;
       }
       SetStyleToDefault();
       return 0;
     }
     else
     {
       std::cout << "Drawer " << who << " not in list" << std::endl;
       Print("DRAWER");
       return -1;
     }
   }
   else
   {
     for (iter = DrawerList.begin(); iter != DrawerList.end(); ++iter)
     {
       if (opt == "DRAW")
       {
         iter->second->Draw(what);
       }
       else if (opt == "PS")
       {
         iter->second->MakePS(what);
       }
       else if (opt == "HTML")
       {
         if (verbosity > 0)
         {
           std::cout << __PRETTY_FUNCTION__ << " creating html output for "
                     << iter->second->Name() << std::endl;
         }
         gROOT->Reset();
         iter->second->isHtml(true);
         int iret = iter->second->MakeHtml(what);
         if (iret)
         {
           std::cout << "subsystem " << iter->second->Name()
                     << " not in root file, skipping" << std::endl;
           // delete all canvases (no more piling up of 50 canvases)
           // if run for a single subsystem this leaves the canvas intact
           // for debugging
           TSeqCollection *allCanvases = gROOT->GetListOfCanvases();
           TCanvas *canvas = nullptr;
           while ((canvas = static_cast<TCanvas *>(allCanvases->First())))
           {
             std::cout << "Deleting Canvas " << canvas->GetName() << std::endl;
             delete canvas;
           }
         }
       }
       SetStyleToDefault();
     }
   }
   return 0;
 }
 
 int OnlMonClient::requestHistoByName(const std::string &subsys, const std::string &what)
 {
   std::string hostname = "UNKNOWN";
   int moniport = OnlMonDefs::MONIPORT;
   std::map<std::string, std::map<const std::string, ClientHistoList *>>::const_iterator histos = SubsysHisto.find(subsys);
   auto histoiter = histos->second.find(what);
   if (Verbosity() > 2)
   {
     std::cout << __PRETTY_FUNCTION__ << "checking for " << what << " on monitor " << subsys << std::endl;
   }
   if (histoiter != histos->second.end())
   {
     hostname = histoiter->second->ServerHost();
     moniport = histoiter->second->ServerPort();
     if (hostname == "UNKNOWN")
     {
       if (LocateHistogram(what, subsys) < 1)
       {
         std::cout << "Histogram " << what << " cannot be located" << std::endl;
         return -1;
       }
       // search again since LocateHistogram can change the map
       histoiter = histos->second.find(what);
       hostname = histoiter->second->ServerHost();
       moniport = histoiter->second->ServerPort();
       if (hostname == "UNKNOWN")
       {
         std::cout << __PRETTY_FUNCTION__ << "host UNKNOWN for whatever reason" << std::endl;
         return -3;
       }
     }
   }
   else
   {
     if (LocateHistogram(what, subsys) < 1)
     {
       std::cout << "Histogram " << what << " cannot be located" << std::endl;
       return -2;
     }
     histoiter = histos->second.find(what);
     if (histoiter != histos->second.end())
     {
       hostname = histoiter->second->ServerHost();
       moniport = histoiter->second->ServerPort();
       if (hostname == "UNKNOWN")
       {
         std::cout << __PRETTY_FUNCTION__ << "host UNKNOWN for whatever reason" << std::endl;
         return -3;
       }
     }
     else
     {
       std::cout << __PRETTY_FUNCTION__ << "Problem determining host" << std::endl;
     }
   }
   // Open connection to server
   TSocket sock(hostname.c_str(), moniport);
   TMessage *mess;
   std::string fullhistoname = subsys + std::string(" ") + what;
   if (Verbosity() > 2)
   {
     std::cout << __PRETTY_FUNCTION__ << " sending " << fullhistoname << " to " << hostname << " port " << moniport << std::endl;
   }
   sock.Send(fullhistoname.c_str());
   while (true)
   {
     if (verbosity > 1)
     {
       std::cout << __PRETTY_FUNCTION__ << "Waiting for Message from : " << hostname
                 << " on port " << moniport << std::endl;
     }
     sock.Recv(mess);
     if (!mess)  // if server is not up mess is NULL
     {
       std::cout << __PRETTY_FUNCTION__ << "Server not running on " << hostname << std::endl;
       sock.Close();
       return 1;
     }
     if (mess->What() == kMESS_STRING)
     {
       char str[OnlMonDefs::MSGLEN];
       mess->ReadString(str, OnlMonDefs::MSGLEN);
       delete mess;
       if (verbosity > 1)
       {
         std::cout << __PRETTY_FUNCTION__ << "Message: " << str << std::endl;
       }
       if (!strcmp(str, "Finished"))
       {
         break;
       }
       else if (!strcmp(str, "UnknownHisto"))
       {
         break;
       }
       else
       {
         std::cout << __PRETTY_FUNCTION__ << "Unknown Text Message: " << str << std::endl;
         sock.Send("Ack");
       }
     }
     else if (mess->What() == kMESS_OBJECT)
     {
       TH1 *histo = static_cast<TH1 *>(mess->ReadObjectAny(mess->GetClass()));
       delete mess;
       TH1 *maphist = static_cast<TH1 *>(histo->Clone(histo->GetName()));
       if (verbosity > 1)
       {
         std::cout << __PRETTY_FUNCTION__ << "histoname: " << histo->GetName() << " at "
                   << histo << std::endl;
       }
 
       updateHistoMap(subsys, histo->GetName(), maphist);
       delete histo;
       sock.Send("Ack");
     }
   }
   sock.Send("Finished");  // tell server we are finished
   // Close the socket
   sock.Close();
   return 0;
 }
 
 int OnlMonClient::requestHisto(const std::string &what, const std::string &hostname, const int moniport)
 {
   // Open connection to server
   TSocket sock(hostname.c_str(), moniport);
   TMessage *mess;
   sock.Send(what.c_str());
   while (true)
   {
     sock.Recv(mess);
     if (!mess)  // if server is not up mess is NULL
     {
       std::cout << __PRETTY_FUNCTION__ << "Server not running on " << hostname << std::endl;
       sock.Close();
       return 1;
     }
     if (mess->What() == kMESS_STRING)
     {
       char str[OnlMonDefs::MSGLEN];
       mess->ReadString(str, OnlMonDefs::MSGLEN);
       delete mess;
       if (verbosity > 1)
       {
         std::cout << __PRETTY_FUNCTION__ << "Message: " << str << std::endl;
       }
 
       if (!strcmp(str, "Finished"))
       {
         break;
       }
       else if (!strcmp(str, "UnknownHisto"))
       {
         break;
       }
       else
       {
         std::cout << __PRETTY_FUNCTION__ << "Unknown Text Message: " << str << std::endl;
         sock.Send("Ack");
       }
     }
     else if (mess->What() == kMESS_OBJECT)
     {
       // this reads the message and allocate space for new histogram
       TH1 *histo = static_cast<TH1 *>(mess->ReadObjectAny(mess->GetClass()));
       delete mess;
       if (verbosity > 1)
       {
         std::cout << __PRETTY_FUNCTION__ << "histoname: " << histo->GetName() << " at "
                   << histo << std::endl;
       }
 
       updateHistoMap(what, histo->GetName(), histo);
       sock.Send("Ack");
     }
   }
   sock.Send("Finished");  // tell server we are finished
 
   // Close the socket
   sock.Close();
   return 0;
 }
 
 int OnlMonClient::requestMonitorList(const std::string &hostname, const int moniport)
 {
   TSocket sock(hostname.c_str(), moniport);
   TMessage *mess;
   sock.Send("LISTMONITORS");
   sock.Recv(mess);
   if (!mess)  // if server is not up mess is NULL
   {
     std::cout << __PRETTY_FUNCTION__ << "Server not running on " << hostname << std::endl;
     sock.Close();
     return 1;
   }
   delete mess;
   while (true)
   {
     sock.Recv(mess);
     if (mess->What() == kMESS_STRING)
     {
       char strmess[OnlMonDefs::MSGLEN];
       mess->ReadString(strmess, OnlMonDefs::MSGLEN);
       delete mess;
       if (Verbosity() > 1)
       {
         std::cout << "received " << strmess << std::endl;
       }
       std::string str(strmess);
       if (str == "Finished")
       {
         break;
       }
       if (Verbosity() > 2)
       {
         std::cout << "inserting " << str << " on host " << hostname
                   << " listening to " << moniport << std::endl;
       }
       MonitorHostPorts.insert(std::make_pair(str, std::make_pair(hostname, moniport)));
     }
     else
     {
       std::cout << "requestMonitorList: received unexpected message type: " << mess->What() << std::endl;
       break;
     }
   }
   sock.Send("Finished");  // tell server we are finished
 
   // Close the socket
   sock.Close();
   return 0;
 }
 
 int OnlMonClient::requestHistoList(const std::string &subsys, const std::string &hostname, const int moniport, std::list<std::string> &histolist)
 {
   // Open connection to server
   TSocket sock(hostname.c_str(), moniport);
   TMessage *mess;
   sock.Send("LIST");
   std::list<std::string>::const_iterator listiter;
   sock.Recv(mess);
   if (!mess)  // if server is not up mess is NULL
   {
     std::cout << __PRETTY_FUNCTION__ << "Server not running on " << hostname << std::endl;
     sock.Close();
     return 1;
   }
 
   delete mess;
   for (listiter = histolist.begin(); listiter != histolist.end(); ++listiter)
   {
     if (Verbosity() > 2)
     {
       std::cout << __PRETTY_FUNCTION__ << "asking for " << *listiter << std::endl;
     }
     sock.Send((*listiter).c_str());
     sock.Recv(mess);
     if (!mess)
     {
       std::cout << __PRETTY_FUNCTION__ << "Server shut down during getting histo list" << std::endl;
       sock.Close();
       return 1;
     }
     if (mess->What() == kMESS_STRING)
     {
       char str[OnlMonDefs::MSGLEN];
       mess->ReadString(str, OnlMonDefs::MSGLEN);
       delete mess;
       if (verbosity > 1)
       {
         std::cout << __PRETTY_FUNCTION__ << "Message: " << str << std::endl;
       }
 
       if (!strcmp(str, "Ack"))
       {
         break;
       }
       else if (!strcmp(str, "UnknownHisto"))
       {
         break;
       }
       else
       {
         std::cout << __PRETTY_FUNCTION__ << "Unknown Text Message: " << str << std::endl;
       }
     }
     else if (mess->What() == kMESS_OBJECT)
     {
       // this reads the message and allocate space for new histogram
       TH1 *histo = static_cast<TH1 *>(mess->ReadObjectAny(mess->GetClass()));
       delete mess;
       if (verbosity > 1)
       {
         std::cout << __PRETTY_FUNCTION__ << "histoname: " << histo->GetName() << " at "
                   << histo << std::endl;
       }
 
       updateHistoMap(subsys, histo->GetName(), histo);
     }
   }
   sock.Send("alldone");
   sock.Recv(mess);
   delete mess;
   sock.Send("Finished");  // tell server we are finished
 
   // Close the socket
   sock.Close();
   return 0;
 }
 
 void OnlMonClient::updateHistoMap(const std::string &subsys, const std::string &hname, TH1 *h1d)
 {
   auto subsysiter = SubsysHisto.find(subsys);
   if (subsysiter == SubsysHisto.end())
   {
     std::map<const std::string, ClientHistoList *> newmap;
     ClientHistoList *entry = new ClientHistoList(subsys);
     entry->Histo(h1d);
     newmap.insert(std::make_pair(hname, entry));
     SubsysHisto.insert(std::make_pair(subsys, newmap));
     return;
   }
   auto histoiter = subsysiter->second.find(hname);
   //  std::map<const std::string, ClientHistoList *>::const_iterator histoiter = Histo.find(hname);
   if (histoiter != subsysiter->second.end())
   {
     if (Verbosity() > 2)
     {
       std::cout << "deleting histogram " << hname << " at " << Histo[hname] << std::endl;
     }
     delete histoiter->second->Histo();  // delete old histogram
     histoiter->second->Histo(h1d);
   }
   else
   {
     ClientHistoList *newhisto = new ClientHistoList(subsys);
     newhisto->Histo(h1d);
     subsysiter->second.insert(std::make_pair(hname, newhisto));
     if (Verbosity() > 2)
     {
       std::cout << "new histogram " << hname << " at " << newhisto->Histo() << std::endl;
     }
   }
   return;
 }
 
 OnlMonDraw *
 OnlMonClient::getDrawer(const std::string &name)
 {
   std::map<const std::string, OnlMonDraw *>::iterator iter = DrawerList.find(name);
   if (iter != DrawerList.end())
   {
     return iter->second;
   }
   std::cout << "Could not locate drawer" << name << std::endl;
   return nullptr;
 }
 
 TH1 *OnlMonClient::getHisto(const std::string &monitor, const std::string &hname)
 {
   auto subsysiter = SubsysHisto.find(monitor);
   if (subsysiter == SubsysHisto.end())
   {
     return nullptr;
   }
   auto hiter = subsysiter->second.find(hname);
   if (hiter == subsysiter->second.end())
   {
     return nullptr;
   }
   return hiter->second->Histo();
 }
 
 void OnlMonClient::Print(const char *what)
 {
   if (!strcmp(what, "ALL") || !strcmp(what, "DRAWER"))
   {
     // loop over the map and print out the content (name and location in memory)
     std::cout << "--------------------------------------" << std::endl
               << std::endl;
     std::cout << "List of Drawers in OnlMonClient:" << std::endl;
 
     std::map<const std::string, OnlMonDraw *>::const_iterator hiter;
     for (hiter = DrawerList.begin(); hiter != DrawerList.end(); ++hiter)
     {
       std::cout << hiter->first << " is at " << hiter->second << std::endl;
     }
     std::cout << std::endl;
   }
   if (!strcmp(what, "ALL") || !strcmp(what, "SERVERS"))
   {
     // loop over the map and print out the content (name and location in memory)
     std::cout << "--------------------------------------" << std::endl
               << std::endl;
     std::cout << "List of Servers in OnlMonClient:" << std::endl;
 
     std::vector<std::string>::iterator hostiter;
     for (hostiter = MonitorHosts.begin(); hostiter != MonitorHosts.end(); ++hostiter)
     {
       std::cout << "ServerHost: " << *hostiter << std::endl;
     }
   }
   if (!strcmp(what, "ALL") || !strcmp(what, "MONITORS"))
   {
     // loop over the map and print out the content (name and location in memory)
     std::cout << "--------------------------------------" << std::endl
               << std::endl;
     std::cout << "List of Monitors in OnlMonClient:" << std::endl;
 
     for (auto &moniiter : MonitorHostPorts)
     {
       std::cout << "Monitor " << moniiter.first << " runs on " << moniiter.second.first
                 << " listening to port " << moniiter.second.second << std::endl;
     }
   }
   if (!strcmp(what, "ALL") || !strcmp(what, "HISTOS"))
   {
     // loop over the map and print out the content (name and location in memory)
     std::cout << "--------------------------------------" << std::endl
               << std::endl;
     std::cout << "List of Histograms in OnlMonClient:" << std::endl;
 
     std::map<const std::string, ClientHistoList *>::const_iterator hiter;
     for (hiter = Histo.begin(); hiter != Histo.end(); ++hiter)
     {
       if (hiter->second)
       {
       std::cout << hiter->first << " Address " << hiter->second->Histo()
                 << " on host " << hiter->second->ServerHost()
                 << " port " << hiter->second->ServerPort()
                 << ", subsystem " << hiter->second->SubSystem() << std::endl;
       }
     }
     std::cout << std::endl;
     for (auto &subs : SubsysHisto)
     {
       auto subiter = MonitorHostPorts.find(subs.first);
       if (subiter != MonitorHostPorts.end())
       {
         std::cout << "Subsystem " << subs.first << " runs on " << subiter->second.first;
         std::cout << " on port " << subiter->second.second << std::endl;
       }
       for (auto &histos : subs.second)
       {
         std::cout << histos.first << " @ " << subs.first
                   << " Address " << histos.second->Histo()
                   << " on host " << histos.second->ServerHost()
                   << " port " << histos.second->ServerPort()
                   << ", subsystem " << histos.second->SubSystem() << std::endl;
       }
     }
     std::cout << std::endl;
   }
   if (!strcmp(what, "ALL") || !strcmp(what, "UNKNOWN"))
   {
     // loop over the map and print out the content (name and location in memory)
     std::cout << "--------------------------------------" << std::endl
               << std::endl;
     std::cout << "List of Unknown Histograms in OnlMonClient:" << std::endl;
 
     std::map<const std::string, ClientHistoList *>::const_iterator hiter;
     for (hiter = Histo.begin(); hiter != Histo.end(); ++hiter)
     {
       if (hiter->second)
       {
     if (hiter->second->ServerHost() == "UNKNOWN" ||
         hiter->second->SubSystem() == "UNKNOWN")
     {
       std::cout << hiter->first << " Address " << hiter->second->Histo()
             << " on host " << hiter->second->ServerHost()
             << " port " << hiter->second->ServerPort()
             << ", subsystem " << hiter->second->SubSystem() << std::endl;
     }
       }
     }
     std::cout << std::endl;
     for (auto &subs : SubsysHisto)
     {
       for (auto &histos : subs.second)
       {
     if ( histos.second->ServerHost() == "UNKNOWN" ||
          histos.second->SubSystem() == "UNKNOWN")
     {
       std::cout << histos.first << " @ " << subs.first
             << " Address " << histos.second->Histo()
             << " on host " << histos.second->ServerHost()
             << " port " << histos.second->ServerPort()
             << ", subsystem " << histos.second->SubSystem() << std::endl;
     }
       }
     }
     std::cout << std::endl;
   }
   return;
 }
 
 void OnlMonClient::PrintHistos(const std::string &what)
 {
   std::cout << "--------------------------------------" << std::endl
             << std::endl;
   std::cout << "List of Histograms in OnlMonClient:" << std::endl;
   auto iter = SubsysHisto.find(what);
   if (iter == SubsysHisto.end())
   {
     std::cout << "subsystem " << what << " not found, available: " << std::endl;
     for (auto &subs : SubsysHisto)
     {
       std::cout << subs.first << std::endl;
     }
     return;
   }
   auto subiter = MonitorHostPorts.find(iter->first);
   if (subiter != MonitorHostPorts.end())
   {
     std::cout << "Subsystem " << iter->first << " runs on " << subiter->second.first;
     std::cout << " on port " << subiter->second.second << std::endl;
   }
   for (auto &histos : iter->second)
   {
     std::cout << histos.first << " @ " << iter->first
               << " Address " << histos.second->Histo()
               << " on host " << histos.second->ServerHost()
               << " port " << histos.second->ServerPort()
               << ", subsystem " << histos.second->SubSystem() << std::endl;
   }
   std::cout << std::endl;
   return;
 }
 
 int OnlMonClient::UpdateServerHistoMap(const std::string &hname, const std::string &subsys, const std::string &hostname)
 {
   // Open connection to server
   std::string searchstring = subsys + ' ' + hname;
   int MoniPort = OnlMonDefs::MONIPORT;
   int foundit = 0;
   do
   {
     std::cout << "Connecting to " << hostname << ", if it is frozen here - this is the one you need to restart" << std::endl;
     TSocket sock(hostname.c_str(), MoniPort);
     TMessage *mess;
     if (verbosity > 0)
     {
       std::cout << "UpdateServerHistoMap: sending cmd HistoList to "
                 << hostname << " on port "
                 << MoniPort
                 << std::endl;
     }
     if (!sock.Send("HistoList"))
     {
       std::cout << "Server not running on " << hostname
                 << " port " << MoniPort << std::endl;
       goto noserver;
     }
     while (true)
     {
       if (verbosity > 0)
       {
         std::cout << "UpdateServerHistoMap: waiting for response on "
                   << hostname << " on port "
                   << MoniPort
                   << std::endl;
       }
       sock.Recv(mess);
       if (!mess)  // if server is not up mess is NULL
       {
         std::cout << "UpdateServerHistoMap: No Recv, Server not running on "
                   << hostname
                   << " on port " << MoniPort << std::endl;
         goto noserver;
       }
       if (mess->What() == kMESS_STRING)
       {
         char strchr[OnlMonDefs::MSGLEN];
         mess->ReadString(strchr, OnlMonDefs::MSGLEN);
         delete mess;
         std::string str = strchr;
         if (verbosity > 0)
         {
           std::cout << "UpdateServerHistoMap Response: " << str << std::endl;
         }
         if (str == "Finished")
         {
           break;
         }
 
         if (str == searchstring)
         {
           std::cout << "found subsystem " << subsys << " histo " << hname << std::endl;
           foundit = 1;
         }
         unsigned int pos_space = str.find(' ');
         PutHistoInMap(str.substr(pos_space + 1, str.size()), str.substr(0, pos_space), hostname, MoniPort);
         sock.Send("Ack");
       }
     }
     sock.Send("Finished");  // tell server we are finished
 
     // Close the socket
   noserver:
     sock.Close();
     if (foundit)
     {
       return foundit;
     }
     MoniPort++;
   } while ((MoniPort - OnlMonDefs::MONIPORT) < OnlMonDefs::NUMMONIPORT);  // no more than NUMMONIPORT parallel servers
   return foundit;
 }
 
 void OnlMonClient::PutHistoInMap(const std::string &hname, const std::string &subsys, const std::string &hostname, const int port)
 {
   auto hiter = SubsysHisto.find(subsys);
   if (hiter == SubsysHisto.end())
   {
     std::map<const std::string, ClientHistoList *> entry;
     // c++11 map.insert returns pair<iterator,bool>
     hiter = SubsysHisto.insert(std::make_pair(subsys, entry)).first;
   }
   auto histoiter = hiter->second.find(hname);
   if (histoiter != hiter->second.end())
   {
     histoiter->second->ServerHost(hostname);
     histoiter->second->ServerPort(port);
   }
   else
   {
     ClientHistoList *newhisto = new ClientHistoList();
     newhisto->ServerHost(hostname);
     newhisto->ServerPort(port);
     hiter->second.insert(std::make_pair(hname, newhisto));
   }
   return;
 }
 
 void OnlMonClient::AddServerHost(const std::string &hostname)
 {
   if (find(MonitorHosts.begin(), MonitorHosts.end(), hostname) != MonitorHosts.end())
   {
     if (Verbosity() > 2)
     {
       std::cout << "Host " << hostname << " already in list" << std::endl;
     }
   }
   else
   {
     MonitorHosts.emplace_back(hostname);
   }
   return;
 }
 
 int OnlMonClient::LocateHistogram(const std::string &hname, const std::string &subsys)
 {
   for (auto &hostiter : MonitorHosts)
   {
     if (UpdateServerHistoMap(hname, subsys, hostiter) > 0)
     {
       return 1;
     }
   }
   return 0;
 }
 
 int OnlMonClient::RunNumber()
 {
   int runno = -9999;
   for (const auto &frwrkiter : m_MonitorFetchedSet)
   {
     TH1 *frameworkvars = getHisto(frwrkiter, "FrameWorkVars");
     if (frameworkvars)
     {
       runno = std::max(runno, (int) frameworkvars->GetBinContent(RUNNUMBERBIN));
     }
   }
   return (runno);
 }
 
 int OnlMonClient::GetServerInfo()
 {
   std::map<std::string, int> server_runmap;
   int runno = -9999;
   for (const auto &frwrkiter : m_MonitorFetchedSet)
   {
     if (m_ServerStatsMap.find(frwrkiter) == m_ServerStatsMap.end())
     {
       m_ServerStatsMap[frwrkiter] = std::make_tuple(false, -1, -1, 0, -1);
     }
     TH1 *frameworkvars = getHisto(frwrkiter, "FrameWorkVars");
     if (frameworkvars)
     {
       int runnumber = frameworkvars->GetBinContent(RUNNUMBERBIN);
       time_t currtime = frameworkvars->GetBinContent(CURRENTTIMEBIN);
       int eventcounter = frameworkvars->GetBinContent(EVENTCOUNTERBIN);
       int gl1foundcounter = frameworkvars->GetBinContent(GL1COUNTERBIN);
       if (Verbosity() > 0)
       {
         std::cout << "Run number for " << frwrkiter << " is "
                   << runnumber
                   << " events taken: " << eventcounter;
     if (gl1foundcounter > -1)
       {
         std::cout << " gl1 found " << gl1foundcounter; 
       }
     std::cout  << " time is " << ctime(&currtime);  // ctime adds eol
       }
       runno = std::max(runno, runnumber);
       server_runmap[frwrkiter] = runnumber;
         auto &statsiter = m_ServerStatsMap[frwrkiter];
         std::get<0>(statsiter) = true;
         std::get<1>(statsiter) = runnumber;
         std::get<2>(statsiter) = eventcounter;
         std::get<3>(statsiter) = currtime;
         std::get<4>(statsiter) = gl1foundcounter;
     }
   }
   for (auto const &iter : server_runmap)
   {
     if (iter.second != runno)
     {
       std::cout << "server " << iter.first << " has bad run " << iter.second << std::endl;
       std::cout << "Resetting histos for " << iter.first << std::endl;
       std::get<0>(m_ServerStatsMap[iter.first]) = false;
       auto subsysiter = SubsysHisto.find(iter.first);
       if (subsysiter == SubsysHisto.end())
       {
         std::cout << "could not find " << iter.first << " in SubsysHisto map" << std::endl;
       }
       else
       {
         for (auto &hiter : subsysiter->second)
         {
           if (hiter.first != "FrameWorkVars")
           {
             if (hiter.second->Histo())
             {
               hiter.second->Histo()->Reset();
             }
           }
         }
       }
     }
   }
   return (runno);
 }
 
 std::pair<time_t,int> OnlMonClient::EventTime(const std::string &which)
 {
   time_t tret = 0;
   int color = 1; // default is black
   for (const auto &frwrkiter : m_MonitorFetchedSet)
   {
     tret = std::max(tret, EventTime(frwrkiter, which));
   }
 
   if (verbosity > 0)
   {
     std::cout << "Time is " << ctime(&tret) << std::endl;
   }
   if (!make_html)
     {
       time_t clienttime = time(nullptr);
       if ((clienttime - tret) > 600)
     {
       color = 2; // turn red if time is off
     }
     }
   return (std::make_pair(tret,color));
 }
 
 time_t OnlMonClient::EventTime(const std::string &servername, const std::string &which)
 {
   time_t tret = 0;
   int ibin = 0;
   if (which == "BOR")
   {
     ibin = BORTIMEBIN;
   }
   else if (which == "CURRENT")
   {
     ibin = CURRENTTIMEBIN;
   }
   else if (which == "EOR")
   {
     ibin = EORTIMEBIN;
   }
   else
   {
     std::cout << "Bad Option for Time: " << which
               << ", implemented are BOR EOR CURRENT" << std::endl;
     ibin = CURRENTTIMEBIN;
   }
   TH1 *frameworkvars = getHisto(servername, "FrameWorkVars");
   if (frameworkvars == nullptr)
   {
     tret = 0;
   }
   else
   {
     tret = (time_t) frameworkvars->GetBinContent(ibin);
   }
   if (verbosity > 0)
   {
     std::cout << "Time is " << ctime(&tret) << std::endl;
   }
   return (tret);
 }
 
 int OnlMonClient::ReadHistogramsFromFile(const std::string &filename, OnlMonDraw *drawer)
 {
   std::string subsys = ExtractSubsystem(filename, drawer);
   std::cout << "Reading histos from " << filename << std::endl;
   TFile *histofile = TFile::Open(filename.c_str(), "READ");
   if (!histofile)
   {
     std::cout << "Can't open " << filename << std::endl;
     return -1;
   }
   TIterator *titer = histofile->GetListOfKeys()->MakeIterator();
   TObject *obj;
   TH1 *histo, *histoptr;
   while ((obj = titer->Next()))
   {
     if (verbosity > 0)
     {
       std::cout << "TObject at " << obj << std::endl;
       std::cout << obj->GetName() << std::endl;
       std::cout << obj->ClassName() << std::endl;
     }
     histofile->GetObject(obj->GetName(), histoptr);
     if (histoptr)
     {
 // this is hokey but it seems to work, the SetDirectory(0) disconnects
 // the histo from the TFile and the static cast makes it work with our
 // histomap (otherwise something throws an exception)
       histoptr->SetDirectory(0);
       histo = dynamic_cast<TH1 *>(histoptr);
       updateHistoMap(subsys, histo->GetName(), histo);
       if (verbosity > 0)
       {
         std::cout << "HistoName: " << histo->GetName() << std::endl;
         std::cout << "HistoClass: " << histo->ClassName() << std::endl;
       }
     }
   }
   delete titer;
 // this is a fast way to close a file, if you call TFile->Close() it deletes all
 // histograms which can take a really long time (hours)
   gROOT->GetListOfFiles()->Remove( histofile );
   return 0;
 }
 
 int OnlMonClient::SendCommand(const char *hostname, const int port, const char *cmd)
 {
   // Open connection to server
   TSocket sock(hostname, port);
   TMessage *mess;
   if (!sock.Send(cmd))
   {
     std::cout << "Server not running on " << hostname
               << " port " << port << std::endl;
     sock.Close();
     return -1;
   }
   while (true)
   {
     sock.Recv(mess);
     if (!mess)  // if server is not up mess is NULL
     {
       std::cout << __PRETTY_FUNCTION__ << "No Recv, Server not running on " << hostname
                 << " on port " << port << std::endl;
       sock.Close();
       return -1;
     }
     if (mess->What() == kMESS_STRING)
     {
       char str[OnlMonDefs::MSGLEN];
       mess->ReadString(str, OnlMonDefs::MSGLEN);
       delete mess;
       if (verbosity > 1)
       {
         std::cout << __PRETTY_FUNCTION__ << " Message: " << str << std::endl;
       }
 
       if (!strcmp(str, "Finished"))
       {
         break;
       }
     }
   }
   sock.Send("Finished");  // tell server we are finished
 
   // Close the socket
   sock.Close();
   return 0;
 }
 
 //_____________________________________________________________________________
 void OnlMonClient::Verbosity(const int v)
 {
   verbosity = v;
   if (fHtml)
   {
     fHtml->verbosity(v);
   }
 }
 
 //_____________________________________________________________________________
 void OnlMonClient::htmlAddMenu(const OnlMonDraw &drawer,
                                const std::string &path,
                                const std::string &relfilename)
 {
   fHtml->addMenu(drawer.Name(), path, relfilename);
 }
 
 //_____________________________________________________________________________
 void OnlMonClient::htmlNamer(const OnlMonDraw &drawer,
                              const std::string &basefilename,
                              const std::string &ext,
                              std::string &fullfilename,
                              std::string &filename)
 {
   fHtml->namer(drawer.Name(), basefilename, ext, fullfilename, filename);
 }
 
 //_____________________________________________________________________________
 std::string
 OnlMonClient::htmlRegisterPage(const OnlMonDraw &drawer,
                                const std::string &path,
                                const std::string &basefilename,
                                const std::string &ext)
 {
   return fHtml->registerPage(drawer.Name(), path, basefilename, ext);
 }
 
 int OnlMonClient::CanvasToPng(TCanvas *canvas, std::string const &pngfilename)
 {
   // in order not to collide when running multiple html generators
   // create a unique filename (okay tempnam is not totally safe against
   // multiple procs getting the same name but the local /tmp filesystem should
   // prevent at least multiple machines colliding)
   // returned char array needs to be free'd after use
   if (!canvas)
   {
     std::cout << __PRETTY_FUNCTION__ << " TCanvas is Null Pointer" << std::endl;
     return -2;
   }
   if (pngfilename.empty())
   {
     std::cout << __PRETTY_FUNCTION__ << " emtpy png filename, not saving TCanvas "
               << canvas->GetName() << std::endl;
     return -1;
   }
   // uuid_t uu;
   // uuid_generate(uu);
   // char uuid[50];
   // uuid_unparse(uu, uuid);
   // std::string tmpname = "/tmp/TC" + std::string(uuid);
   // canvas->Print(tmpname.c_str(), "gif");  // write gif format
   // TImage *img = TImage::Open(tmpname.c_str());
   // img->WriteImage(pngfilename.c_str());
   // delete img;
   // if (remove(tmpname.c_str()))
   // {
   //   std::cout << "Error removing " << tmpname << std::endl;
   // }
   canvas->SaveAs(pngfilename.c_str());
   return 0;
 }
 
 int OnlMonClient::HistoToPng(TH1 *histo, std::string const &pngfilename, const char *drawopt, const int statopt)
 {
   TCanvas *cgiCanv = new TCanvas("cgiCanv", "cgiCanv", 200, 200, 650, 500);
   gStyle->SetOptStat(statopt);
   cgiCanv->SetFillColor(0);
   cgiCanv->SetBorderMode(0);
   cgiCanv->SetBorderSize(2);
   cgiCanv->SetFrameFillColor(0);
   cgiCanv->SetFrameBorderMode(0);
   cgiCanv->SetTickx();
   cgiCanv->SetTicky();
   cgiCanv->cd();
   histo->SetMarkerStyle(8);
   histo->SetMarkerSize(0.15);
   histo->Draw(drawopt);
   uuid_t uu;
   uuid_generate(uu);
   char uuid[50];
   uuid_unparse(uu, uuid);
   std::string tmpname = "/tmp/TC" + std::string(uuid);
   cgiCanv->Print(tmpname.c_str(), "gif");
   TImage *img = TImage::Open(tmpname.c_str());
   img->WriteImage(pngfilename.c_str());
   if (remove(tmpname.c_str()))
   {
     std::cout << "Error removing " << tmpname << std::endl;
   }
   delete cgiCanv;
   return 0;
 }
 
 int OnlMonClient::SaveLogFile(const OnlMonDraw &drawer)
 {
   // sendfile example shamelessly copied from
   // http://www.linuxgazette.com/issue91/tranter.html
   std::ostringstream logfilename;
   const char *logdir = getenv("ONLMON_LOGDIR");
   if (logdir)
   {
     logfilename << logdir << "/";
   }
   int irun = RunNumber();
   logfilename << drawer.Name() << "_" << irun << ".log.gz";
   std::ifstream infile(logfilename.str().c_str(), std::ios_base::binary);
   if (infile.good())
   {
     std::string outfilename = htmlRegisterPage(drawer, "Logfile", "log", "txt.gz");
     std::ofstream outfile(outfilename.c_str(), std::ios_base::binary);
     outfile << infile.rdbuf();
     infile.close();
     outfile.close();
   }
   return 0;
 }
 
 int OnlMonClient::SetStyleToDefault()
 {
   defaultStyle->cd();
   defaultStyle->Reset();
   defaultStyle->SetFrameBorderMode(0);
   defaultStyle->SetCanvasColor(0);
   defaultStyle->SetPadBorderMode(0);
   defaultStyle->SetCanvasBorderMode(0);
   defaultStyle->SetPalette(1, nullptr);
   return 0;
 }
 
 void OnlMonClient::CacheRunDB(const int runno)
 {
   if (runno == cachedrun)
   {
     return;
   }
   standalone = 0;
   cosmicrun = 0;
   runtype = "unknown_runtype";
 
   odbc::Connection *con {nullptr};
   odbc::Statement *query {nullptr};
   std::ostringstream cmd;
   try
   {
     con = odbc::DriverManager::getConnection("daq", "phnxrc", "");
   }
   catch (odbc::SQLException &e)
   {
     printf(" Exception caught during DriverManager::getConnection, Message: %s\n", e.getMessage().c_str());
     return;
   }
 
   query = con->createStatement();
   cmd << "select runnumber from run where runnumber = " << runno;
   odbc::ResultSet *rs = nullptr;
   int ncount = 10;
   while (ncount > 0)
   {
     try
     {
       rs = query->executeQuery(cmd.str());
     }
     catch (odbc::SQLException &e)
     {
       printf("Exception caught for query %s\nMessage: %s", cmd.str().c_str(), e.getMessage().c_str());
     }
     if (!rs->next())
     {
       printf("run table query did not give any result, run %d not in DB yet countdown %d\n", runno, ncount);
       ncount--;
       sleep(10);
       delete rs;
     }
     else
     {
       delete rs;
       break;
     }
   }
   cmd.str("");
   cmd << "SELECT runtype FROM RUN  WHERE RUNNUMBER = "
       << runno;
   if (verbosity > 0)
   {
     printf("command: %s\n", cmd.str().c_str());
   }
   try
   {
     rs = query->executeQuery(cmd.str());
   }
   catch (odbc::SQLException &e)
   {
     printf("Exception caught for query %s\nMessage: %s", cmd.str().c_str(), e.getMessage().c_str());
   }
   if (rs->next())
   {
     runtype = rs->getString("runtype");
     if (runtype == "cosmics")
     {
       cosmicrun = 1;
     }
     else
     {
       cosmicrun = 0;
     }
   }
   delete con;
   cachedrun = runno;
   //  printf("CacheRunDB: runno: %d\n",runno);
   return;
 }
 
 int OnlMonClient::isCosmicRun()
 {
   CacheRunDB(RunNumber());
   return cosmicrun;
 }
 
 int OnlMonClient::isStandalone()
 {
   CacheRunDB(RunNumber());
   return standalone;
 }
 
 std::string
 OnlMonClient::RunType()
 {
   CacheRunDB(RunNumber());
   return runtype;
 }
 
 void OnlMonClient::FindAllMonitors()
 {
   for (auto &hostiter : MonitorHosts)
   {
     if (Verbosity() > 2)
     {
       std::cout << "checking " << hostiter << std::endl;
     }
     for (unsigned int moniport = OnlMonDefs::MONIPORT; moniport < OnlMonDefs::MONIPORT + OnlMonDefs::NUMMONIPORT; ++moniport)
     {
       requestMonitorList(hostiter, moniport);
     }
   }
   return;
 }
 
 int OnlMonClient::FindMonitor(const std::string &name)
 {
   // loop over all hosts/ports until we find ours
   int iret = 0;
   for (auto &hostiter : MonitorHosts)
   {
     if (Verbosity() > 2)
     {
       std::cout << "checking " << hostiter << std::endl;
     }
     for (unsigned int moniport = OnlMonDefs::MONIPORT; moniport < OnlMonDefs::MONIPORT + OnlMonDefs::NUMMONIPORT; ++moniport)
     {
       requestMonitorList(hostiter, moniport);
       if (Verbosity() > 2)
       {
         std::cout << "looking for " << name << std::endl;
       }
       auto moniter = MonitorHostPorts.find(name);
       if (moniter != MonitorHostPorts.end())
       {
         if (Verbosity() > 2)
         {
           std::cout << "found " << name << " running on " << moniter->second.first
                     << " listening to port " << moniter->second.second << std::endl;
         }
         return 1;
       }
     }
   }
   return iret;
 }
 
 int OnlMonClient::IsMonitorRunning(const std::string &name)
 {
   int iret = 0;
   std::string command = std::string("ISRUNNING") + ' ' + name;
   auto moniter = MonitorHostPorts.find(name);
   if (moniter == MonitorHostPorts.end())
   {
     return iret;
   }
   TSocket sock(moniter->second.first.c_str(), moniter->second.second);
   TMessage *mess;
   sock.Send(command.c_str());
   sock.Recv(mess);
   if (!mess)  // if server is not up mess is NULL
   {
     std::cout << __PRETTY_FUNCTION__ << "Server not running on " << moniter->second.first << std::endl;
     sock.Close();
     return iret;
   }
   if (mess->What() == kMESS_STRING)
   {
     char str[OnlMonDefs::MSGLEN];
     mess->ReadString(str, OnlMonDefs::MSGLEN);
     delete mess;
     if (verbosity > 1)
     {
       std::cout << __PRETTY_FUNCTION__ << "Message: " << str << std::endl;
     }
     if (!strcmp(str, "Yes"))
     {
       iret = 1;
     }
   }
   sock.Send("Finished");
   sock.Close();
   return iret;
 }
 
 std::string OnlMonClient::ExtractSubsystem(const std::string &fullfilename, OnlMonDraw *drawer)
 {
   std::string subsys = std::filesystem::path(fullfilename).filename();
   subsys = subsys.substr(subsys.find('-') + 1);
   subsys.resize(subsys.find(".root"));
   m_MonitorFetchedSet.insert(subsys);
   drawer->AddServer(subsys);
   return subsys;
 }
 
 OnlMonDraw *OnlMonClient::GetDrawer(const std::string &name)
 {
   auto iter = DrawerList.find(name);
   if (iter != DrawerList.end())
   {
     return iter->second;
   }
   std::cout << "Cannot locate Drawer " << name << " in my list" << std::endl;
   return nullptr;
 }
 
 void OnlMonClient::SaveServerHistoMap(const std::string &cachefilename)
 {
   std::ofstream cachefile(cachefilename);
   std::cout << "saving histomap to " << cachefilename << std::endl;
   for (auto &subs : SubsysHisto)
   {
     for (auto &histos : subs.second)
     {
       cachefile << histos.second->SubSystem() << " " << histos.first << " " << histos.second->ServerHost() << " " << histos.second->ServerPort() << std::endl;
     }
   }
   cachefile.close();
   return;
 }
 
 void OnlMonClient::ReadServerHistoMap(const std::string &cachefilename)
 {
   std::ifstream cachefile(cachefilename);
   std::string hname;
   std::string subsys;
   std::string hostname;
   int port;
   if (cachefile.good())
   {
     std::cout << "opened histogram map cache file " << cachefilename << std::endl;
     std::string line;
     while (std::getline(cachefile, line))
     {
       std::istringstream iss(line);
       iss >> subsys;
       iss >> hname;
       iss >> hostname;
       iss >> port;
       AddServerHost(hostname);
       PutHistoInMap(hname,subsys,hostname,port);
       MonitorHostPorts.insert(std::make_pair(subsys, std::make_pair(hostname,port)));
     }
     cachefile.close();
   }
   else
   {
     std::cout << "failed to open histogram map cache file " << cachefilename << std::endl;
   }
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team