In This Package:

StatsServerAlg.cc

Go to the documentation of this file.

#include "StatsServerAlg.h"

#include "StatisticsSvc/IStatisticsSvc.h"
#include "TSocket.h"
#include "TServerSocket.h"
#include "TMap.h"
#include "TList.h"
#include "TMonitor.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "TMessage.h"

StatsServerAlg::StatsServerAlg(const std::string& name, 
                               ISvcLocator* pSvcLocator)
  : GaudiAlgorithm(name,pSvcLocator),
    m_statsSvc(0),
    m_server(0),
    m_monitor(0),
    m_clients(0)
{
  declareProperty("ProcessInterval",
                  m_processInterval=1,
                  "Interval for processing requests to server");
  declareProperty("PortNumber",
                  m_portNumber=9090,
                  "Port Number for server");
}

StatsServerAlg::~StatsServerAlg()
{
}

StatusCode StatsServerAlg::initialize()
{
  // Initialize the necessary services
  StatusCode sc = this->service("StatisticsSvc",m_statsSvc,true);
  if(sc.isFailure()){
    error() << "Failed to get StatisticsSvc" << endreq;
    return sc;
  }

  // Start the server
  sc = startServer();
  return sc;
}

StatusCode StatsServerAlg::execute()
{
  static int currentCycle = 0;
  currentCycle += 1;
  StatusCode sc = StatusCode::SUCCESS;
  // Process server requests every 'n' event cycles
  if( currentCycle % m_processInterval == 0 ){
    info() << "Processing requests to server" << endreq;
    sc = processRequests();
  }
  return StatusCode::SUCCESS;
}

StatusCode StatsServerAlg::finalize()
{
  if( m_statsSvc ) m_statsSvc->release();
  StatusCode sc = stopServer();
  return sc;
}


StatusCode StatsServerAlg::startServer(){
  // Start the Server

  m_server = new TServerSocket(m_portNumber, kTRUE);
  if (!m_server->IsValid()){
    error() << "Failed to start server on port " << m_portNumber << endreq;
    return StatusCode::FAILURE;
  }
  m_monitor = new TMonitor;
  m_monitor->Add( m_server );
  m_clients = new TList;
  
  return StatusCode::SUCCESS;
}

StatusCode StatsServerAlg::stopServer(){
  // Stop the Server
  m_clients->Delete();
  delete m_clients;
  delete m_server;
  delete m_monitor;
  return StatusCode::SUCCESS;
}

StatusCode StatsServerAlg::processRequests(){
  // Process any requests from clients
  int timeout = 20; // timeout if no requests after 20ms 
  TSocket* s = m_monitor->Select(timeout);
  if( !s ){
    error() << "Failure in client socket monitor." << endreq;
    return StatusCode::FAILURE;
  }
  if( s == (TSocket*)-1 ){
    // No pending requests before timeout
    return StatusCode::SUCCESS;
  }

  // Found a request
  if( s->IsA() == TServerSocket::Class() ){
    // New connection
    TSocket* sock = ((TServerSocket*)s)->Accept();
    m_monitor->Add(sock);
    m_clients->Add(sock);
    info() << "Accepted connection from client: " 
           << sock->GetInetAddress().GetHostName() << endreq;
    return StatusCode::SUCCESS;
  }

  // Request for statistics service
  char request[1024];
  if (s->Recv(request, sizeof(request)) <= 0) {
    // Closing connection
    m_monitor->Remove(s);
    m_clients->Remove(s);
    info() << "Closed connection from client: " 
           << s->GetInetAddress().GetHostName() << endreq;
    delete s;
    return StatusCode::SUCCESS;
  }

  info() << "Received request: " << request << endreq;

  // Respond to actual request (white-space separated list of paths)
  // Return a TMap of path/result pairs
  
  TMap itemMap;
  TList cleanupList;
  cleanupList.SetOwner();
  TObjString* nullObject = new TObjString("NULL");
  cleanupList.Add( nullObject );

  TString reqStr( request );
  TObjArray* paths = reqStr.Tokenize( " " );
  info() << "Number of requested paths: " << paths->GetEntriesFast() << endreq;
  for(int pathIdx=0; pathIdx<paths->GetEntriesFast(); pathIdx++){

    TObjString* path = new TObjString( *(dynamic_cast<TObjString*>(paths->At(pathIdx))));
    cleanupList.Add( path );
    std::string pathStr( path->GetName() );
    info() << "Retrieving path: \"" << pathStr << "\"" << endreq;

    // Check if path exists
    if(! m_statsSvc->exists( pathStr ) ){
      warning() << "Request for invalid path: " << pathStr << endreq;
      itemMap.Add( path, nullObject );
      continue;
    }

    // Check if path has an object
    TObject* object = m_statsSvc->get( pathStr );
    if( object ){
      info() << "Found object at path: " << pathStr << endreq;
      itemMap.Add( path, object );
      continue;
    }

    // Path is not an object, must be a directory
    std::vector<std::string> subFolds = m_statsSvc->getSubFolders( pathStr );
    TList* subFolders = new TList();
    subFolders->SetName("subFolders");
    subFolders->SetOwner();
    for(size_t idx=0; idx<subFolds.size(); idx++){
      subFolders->Add( new TObjString( subFolds[idx].c_str() ) );
    }

    std::vector<std::string> conts = m_statsSvc->getContents( pathStr );
    TList* contents = new TList();
    contents->SetName("contents");
    contents->SetOwner();
    for(size_t idx=0; idx<conts.size(); idx++){
      contents->Add( new TObjString( conts[idx].c_str() ) );
    }

    TMap* directory = new TMap();
    directory->SetName("directory");
    directory->SetOwner();
    directory->Add(new TObjString("subFolders"),subFolders);
    directory->Add(new TObjString("contents"),contents);
    itemMap.Add( path, directory );
    cleanupList.Add( directory );
  }
  delete paths;

  // Send requested items to client
  TMessage answer(kMESS_OBJECT);
  answer.WriteObject( &itemMap );
  s->Send(answer);

  cleanupList.Delete();

  return StatusCode::SUCCESS;
}

---