NdmcClient.h

Go to the documentation of this file.

/**
 * NdmcClient header file
 * $Id: NdmcClient.h,v 1.28.10.1 2019/09/27 00:07:18 slin Exp $
 */
#ifndef __NDMC_CLIENT_H_
#define __NDMC_CLIENT_H_

#include <map>
#include <typeinfo>
#include <sys/times.h>
#include "boost/thread.hpp"
#include "NovaDAQMonitorClient/Ndmc.h"
#include "NovaDAQMonitorClient/NdmcMetricABC.h"
#include "NovaDAQMonitorClient/NdmcMetric.h"
#include "NovaDAQUtilities/Runnable.h" // base class
#include "ganglia.h"

class NdmcClientTest;

NDMC_NAMESPACE_BEGIN

/**
 * NdmcClient
 *
 * This class implements a NdmcClient client interface for a single process to
 * the daq monitor.    
 * 
 * @author Susan Kasahara
 * @author <a href="mailto:schubert@physics.umn.edu">schubert@physics.umn.edu</a> 
 * @date May 6 2010
 */

class NdmcClient : public novadaq::Runnable {

  friend class ::NdmcClientTest;

 public:

  // Constructor/Destructor 
  NdmcClient(int32_t partition = -1, std::string appName = "", std::string groupName = "", 
             uint32_t sendTimeInterval=15);
  virtual ~NdmcClient();

  void run(); /* required to implement Runnable. Execute in separate thread. */

  // State testing methods
  uint32_t getNumMetric();
  int32_t getPartition() const { return _partition; }
  std::string getApplicationName() const { return _applicationName; }
  std::string getGroupName() const { return _groupName; }
  uint32_t getSendTimeInterval() const { return _sendTimeInterval; }
  
  // State changing methods
  template<class T>
  int32_t createMetric(std::string metricName, std::string units, MetricType_t metricType=VALUE,
                       std::string title = "", std::string description = "");
  template<class T>
  int32_t createMetric(std::string metricName, std::string units, MetricType_t metricType,
                       NdmcMetric<T>*& metricPtr, std::string title = "", 
                       std::string description = "");

  int32_t send();  // will send all owned metrics
  void destroyMetric(int32_t metricID); // remove from map and delete metric with metricID
  void destroyMetrics(); // remove all managed metrics from map and delete 
  bool setPartition(int32_t partition); // partition number (default -1)
  void setApplicationName(std::string appName); // application name (default "")
  void setGroupName(std::string groupName); // group (A:<appname> P<partition> will be appended)
  void setSendTimeInterval(uint32_t sendTimeInterval);

  template<class T>
    bool setValue(int32_t metricId, T value, double weight = 1., int npar=0, double* par=0);
  // use this method if cpu is tight to avoid look-up of metric by id
  template<class T>
    bool setValue(NdmcMetric<T>* metric, T value, double weight = 1., int npar=0, double* par=0); 

  template<class T>
    bool getLastValueSent(int32_t metricId, T& lastValueSent);
  // use this method if cpu is tight to avoid look-up of metric by id
  template<class T>
    bool getLastValueSent(NdmcMetric<T>* metric, T& lastValueSent); 
 
 private:

  int32_t _partition; /**< partition number (0,1,2, or 3) */
  std::string _applicationName; /**< application name, e.g. dcmapp */
  std::string _groupName; /**< group name, defaults to "appName + Ppartition" */
  std::string _userGroupName; /**< user-specified group name */
  uint32_t _sendTimeInterval; /**< time interval at which to send custom metrics */
  std::map<int32_t, NdmcMetricABC*> _metricMap; /**< map by ID/Metric */
  clock_t _lastSendTime;  /**< last send time */
  boost::mutex _mutex; /**< mutex used to control set/send of values */
  boost::thread *_clientThread; /**< thread for this client */

  // Private methods
  bool _timeToSend();
  int32_t _adoptMetric(NdmcMetricABC* metric);
  NdmcMetricABC* _getMetric(int32_t metricId) const;
  void _updateGroupName();

};

/**
 * Create new metric of name metricName.
 * @param metricName - name of this metric.  
 * @param units - units to be displayed on axis of plot, e.g. "Bytes", "Hz"
 * @param metricType - VALUE,COUNTER,RATE,AVERAGE,MAXIMUM,MINIMUM,STDEV,HEARTBEAT
 * @return -1 if error, id number of this metric.
 */
template<class T>
int32_t NdmcClient::createMetric(std::string metricName, std::string units, 
                                 MetricType_t metricType, std::string title,
                                 std::string description) {

  boost::mutex::scoped_lock lock(_mutex);                                                   

  // tmax is the max time in seconds expected between metric sends (appears to be ignored) 
  int32_t tmax = _sendTimeInterval; 
  // dmax is the lifetime in seconds of this metric before it expires in ganglia plots
  int32_t dmax = _sendTimeInterval*2; 
  NdmcMetric<T>* metric = new NdmcMetric<T>(metricName, units, metricType,
                                            tmax, dmax, GANGLIA_SLOPE_BOTH, 
                                            getPartition(), getApplicationName(), getGroupName(),
                                            title, description);

  int32_t metricID = _adoptMetric(metric);

  if ( metricID < 0 ) {
    delete metric;  metric = 0; // adoptMetric failed
  }

  return metricID;

}

/**
 * Create new metric of name metricName.
 * @param metricName - name of this metric.  
 * @param units - units to be displayed on axis of plot, e.g. "Bytes", "Hz"
 * @param metricType - VALUE,COUNTER,RATE,AVERAGE,MAXIMUM,MINIMUM,STDEV,HEARTBEAT
 * @return -1 if error, id number of this metric.
 */
template<class T>
int32_t NdmcClient::createMetric(std::string metricName, std::string units, 
                                 MetricType_t metricType, NdmcMetric<T>*& metricPtr,
                                 std::string title, std::string description) {

  int32_t metricID = createMetric<T>(metricName,units,metricType,title,description);
  metricPtr = NULL;
  if ( metricID >= 0 ) metricPtr = dynamic_cast<NdmcMetric<T>*>(_getMetric(metricID));

  return metricID;

}

/**
 * Set metric value by metricID
 * @param metricID - ID number of this metric
 * @param value - value to set of type T
 * @param weight - optional value (def = 1) only used with metrics of type AVERAGE
 * @return true if successful, else false.  Will fail if metric of ID of type T has not
 *         been created.
 */
template<class T>
bool NdmcClient::setValue(int32_t metricID, T value, double weight, int npar, double* par) { 
                                                                                            
  boost::mutex::scoped_lock lock(_mutex);                                                   
                                                                                            
  NdmcMetric<T>* metric = dynamic_cast<NdmcMetric<T>*>(_getMetric(metricID));             
  if ( !metric ) {                                                                          
    ::mf::LogWarning("NdmcClient") << "NdmcClient::setValue - failed. No metric of id "         
                             << metricID << " of type " << typeid(T).name() << "."  
                             << std::endl;                                                  
    return false;                                                                           
  }                                                                                         
                                                                                            
  metric -> setValue(value, weight);                                                        
                                                                                            
  return true;                                                                              
                                                                                            
}

/**
 * Set metric value by metric ptr.  Recommend the user use setValue by metric id unless
 * performance is an issue.
 *
 * @param metric - ptr of type NdmcMetric<T>* previously created by NdmcClient::createMetric
 * @param value - value to set of type T
 * @param weight - optional value (def = 1) only used with metrics of type AVERAGE
 * @return true if successful, else false.  
 */
template<class T>
bool NdmcClient::setValue(NdmcMetric<T>* metric, T value, double weight, int npar, double* par) { 
                         
  boost::mutex::scoped_lock lock(_mutex);                                                   
                                                                                            
  if ( !metric) {
    ::mf::LogWarning("NdmcClient") << "NdmcClient::setValue - failed.  Passed NULL metric ptr."
                                   << std::endl;
    return false;
  }

  return metric -> setValue(value, weight, npar, par); 
                                                                                            
}

/**
 * Get last metric value sent, by metricID
 * @param metricID - ID number of this metric 
 * @param lastValueSent - reference of type T to return value
 * @return true if successful, else false.  Will fail if metric of ID of type T has not
 *         been created.
 */
template<class T>
bool NdmcClient::getLastValueSent(int32_t metricID, T& lastValueSent) { 
                                                                                            
  boost::mutex::scoped_lock lock(_mutex);                                                   
                                                                                            
  NdmcMetric<T>* metric = dynamic_cast<NdmcMetric<T>*>(_getMetric(metricID));             
  if ( !metric ) {                                                                          
    ::mf::LogWarning("NdmcClient") << "NdmcClient::getLastValueSent - failed. No metric of id "
                                   << metricID << " of type " << typeid(T).name() << "."  
                                   << std::endl;                                                  
    return false;                                                                           
  }                                                                                         
                                                                                            
  return metric -> getLastValueSent(lastValueSent);                      
                                                                                                  
}

/**
 * Get last metric value sent, by metric ptr.  Recommend the user use getLastValueSent, by 
 * metric id unless performance is an issue.
 *
 * @param metric - ptr of type NdmcMetric<T>* previously created by NdmcClient::createMetric
 * @param lastValueSent - reference of type T to return value
 * @return true if successful, else false.  
 */
template<class T>
bool NdmcClient::getLastValueSent(NdmcMetric<T>* metric, T& lastValueSent) { 
                         
  boost::mutex::scoped_lock lock(_mutex);                                                   
                                                                                            
  if ( !metric ) {
    ::mf::LogWarning("NdmcClient") << "NdmcClient::getLastValueSent - failed."
                                   << "  Passed NULL metric ptr." << std::endl;
    return false;
  }

  return metric -> getLastValueSent(lastValueSent);
                                                                                            
}

NDMC_NAMESPACE_END

#endif