HLT/BASE/AliHLTDimServer.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIHLTDIMSERVER_H
   5 #define ALIHLTDIMSERVER_H
   6
   7 //* This file is property of and copyright by the ALICE HLT Project        *
   8 //* ALICE Experiment at CERN, All rights reserved.                         *
   9 //* See cxx source for full Copyright notice                               *
  10
  11 //  @file   AliHLTDimServer.h
  12 //  @author Matthias Richter
  13 //  @date   20010-03-10
  14 //  @brief  HLT DIM server implementation and dynamic access
  15 //          to DIM library
  16
  17 #include "AliHLTLogging.h"
  18 #include "TNamed.h"
  19 #include "TObjArray.h"
  20
  21 class TThread;
  22
  23 /**
  24  * @class AliHLTDimServer
  25  * Implementation of a DIM server for HLT and the dynamic access to the
  26  * DIM  library.
  27  */
  28 class AliHLTDimServer : public TNamed {
  29 public:
  30   AliHLTDimServer();
  31   AliHLTDimServer(const char* servername);
  32   ~AliHLTDimServer();
  33
  34   /// Data type identifiers for services.
  35   enum AliHLTDimServiceDataType{
  36     kDataTypeUnknown = 0, /// initializer
  37     kDataTypeCustom,      /// Custom format maintained by the user.
  38     kDataTypeInt,         /// Integer type
  39     kDataTypeFloat,       /// Float type
  40     kDataTypeString,      /// String type
  41   };
  42
  43   /// The service data field.
  44   struct AliHLTDimServicePoint_t {
  45     union {
  46       int iVal;     /// integer value
  47       float fVal;   /// float value
  48       void* strVal; /// string value, casted to string* before use
  49     };
  50   };
  51
  52   /** @class AliHLTDimService
  53    * Base class for DIM services
  54    */
  55   class AliHLTDimService : public TNamed {
  56   public:
  57     AliHLTDimService();
  58
  59     /**
  60      * Create a new service with a particular predefined type and name.
  61      * \param type  The type of the service
  62      * \param servicename  The name of the service.
  63      */
  64     AliHLTDimService(AliHLTDimServiceDataType type, const char* servicename);
  65
  66     /**
  67      * Create a new service with a particular custom type.
  68      * \param type  The type of the service as a string.
  69      *      The format parameter specifies the contents of the structure in the
  70      *      form T:N[;T:N]*[;T] where T is the item type: (I)nteger, (C)arachter,
  71      *      (L)ong, (S)hort, (F)loat, (D)ouble, X(tra long) and N is the number
  72      *      of such items. The type alone at the end means all following items
  73      *      are of the same type. Example: "I:3;F:2;C" means 3 Integers, 2 Floats
  74      *      and Characters until the end. The format parameter is used for
  75      *      communicating between different platforms.
  76      * \param data  Points to a buffer maintained by the user which stores the
  77      *      data to publish. This buffer must exist as long as the DIM service
  78      *      is registered and active.
  79      * \param size  The size of the data structure pointed to by data.
  80      * \param servicename  The name of the service.
  81      */
  82     AliHLTDimService(const char* type, void* data, int size, const char* servicename);
  83
  84     /**
  85      * Updates the DIM data point for custom data structures.
  86      * i.e. This method should be used if the service was created with:
  87      * AliHLTDimService(const char* type, void* data, int size, const char* servicename)
  88      */
  89     void Update();
  90
  91     /**
  92      * Updates the DIM data point.
  93      * This method should be used if the service was created with:
  94      * AliHLTDimService(AliHLTDimServiceDataType type, const char* servicename)
  95      * \param sp  The new data point to publish via DIM.
  96      */
  97     void Update(const AliHLTDimServicePoint_t& sp);
  98
  99     AliHLTDimServiceDataType GetType() const {return fType;}
 100     const char* GetTypeString() const { return fTypeString.Data(); }
 101     void* GetLocation() {return fDataBuffer;}
 102     int GetId() const {return fId;}
 103     int SetId(int id) {fId=id;return id;}
 104     void* GetDataBuffer() const { return fDataBuffer; }
 105     int GetDataSize() const { return fDataSize; }
 106
 107   private:
 108
 109     // Do not allow copying of this class
 110     AliHLTDimService(const AliHLTDimService&);
 111     AliHLTDimService& operator = (const AliHLTDimService&);
 112
 113     AliHLTDimServicePoint_t fData; /// the data point
 114     AliHLTDimServiceDataType fType; /// type of this service
 115     TString fTypeString;  /// The string representing the service type.
 116     void* fDataBuffer;  /// Pointer to the data buffer.
 117     int fDataSize;  /// The size of the data buffer.
 118     int fId; /// id of the service
 119   };
 120
 121   /** @class AliHLTDimServiceFloat
 122    * DIM service for a float value
 123    */
 124   class AliHLTDimServiceFloat : public AliHLTDimService {
 125   public:
 126     AliHLTDimServiceFloat();
 127     ~AliHLTDimServiceFloat();
 128
 129     void Update(float f) {
 130       AliHLTDimServicePoint_t sp; sp.fVal=f; AliHLTDimService::Update(sp);
 131     }
 132   };
 133
 134   /** @class AliHLTDimServiceInt
 135    * DIM service for a int value
 136    */
 137   class AliHLTDimServiceInt : public AliHLTDimService {
 138   public:
 139     AliHLTDimServiceInt();
 140     ~AliHLTDimServiceInt();
 141
 142     void Update(int i) {
 143       AliHLTDimServicePoint_t sp; sp.iVal=i; AliHLTDimService::Update(sp);
 144     }
 145   };
 146
 147   /**
 148    * Register a service.
 149    * @param pService    the service to be registered
 150    */
 151   int RegisterService(AliHLTDimService* pService);
 152
 153   /**
 154    * Create a service.
 155    * @param type        type of the channel, see @ref ceServiceDataType
 156    * @param name        unique name of the service
 157    * @return dim service object, needs to be cleaned by the caller
 158    */
 159   AliHLTDimService* CreateService(AliHLTDimServiceDataType type, const char* name);
 160
 161   /**
 162    * Create a group of services.
 163    * The names are built from the basename and the number of services.
 164    * @param type        type of the channel
 165    * @param basename    base name of the services, the name might contain a '%d' sequence which is then
 166    *                    replaced by the number, number is appended if no '%d' provided
 167    * @param count       number of services in this group, passed to the <i>update</i> and <i>set</i> function as parameter major
 168    * @return            TObjArray of AliHLTDimService objects, the array needs to be cleaned by the caller
 169    */
 170   TObjArray* CreateServiceGroup(AliHLTDimServiceDataType type, const char* basename, int count);
 171
 172   /// Update all services via the Dim channel
 173   int UpdateServices();
 174
 175   /// init the server
 176   /// load the dim library and function pointers
 177   /// init dim (DNS and server name)
 178   int Init(const char* dimNameServer);
 179
 180   /// Reset
 181   int Reset();
 182
 183   /// start the server
 184   int Start();
 185
 186   /// stop the server
 187   int Stop();
 188
 189 protected:
 190   enum AliHLTDimServerState_t {
 191     // server is not started
 192     kStateOff = 0,
 193     // starting, will be changed by the server thread to kStateRunning
 194     kStateStarting,
 195     // server running
 196     kStateRunning,
 197     // set by the main thread and changed by the server thread before it terminates
 198     kStateStopping,
 199     // error
 200     kStateError
 201   };
 202
 203   int SetState(int state) {fState=state; return fState;}
 204
 205   int GetState() const {return fState;}
 206
 207   typedef void (*fctVoid)();
 208   typedef int (*fctDisServiceCallback)( const char*);
 209   typedef int (*fctDisAddService)     ( const char* service,
 210                                         const char* type,
 211                                         void* buffer,
 212                                         int size,
 213                                         fctDisServiceCallback cb,
 214                                         long int tag);
 215   typedef int (*fctDisRemoveService)  ( unsigned int id);
 216   typedef int (*fctDisUpdateService)  ( unsigned int id);
 217   typedef int (*fctDisCharArg)        ( const char*);
 218   typedef int (*fctDisNoArg)          ( );
 219
 220   /**
 221    * @class AliHLTDimInterface
 222    * Interface to the dim library
 223    */
 224   class AliHLTDimInterface : public AliHLTLogging {
 225   public:
 226     AliHLTDimInterface();
 227     ~AliHLTDimInterface();
 228
 229     /// load the dim library and function pointers
 230     int Init();
 231
 232     int DisAddService(const char* service, const char* type, void* buffer,
 233                       int size, fctDisServiceCallback cb, long int tag) const {
 234       if (fpDisAddService) return (*fpDisAddService)(service, type, buffer, size, cb, tag);
 235       return -ENODEV;
 236     }
 237
 238     int DisAddService(const char* service, const char* type, void* buffer, int size) const {
 239       if (fpDisAddService) return (*fpDisAddService)(service, type, buffer, size, NULL, 0);
 240       return -ENODEV;
 241     }
 242
 243     int DisRemoveService(unsigned int id) const {
 244       if (fpDisRemoveService) return (*fpDisRemoveService)(id);
 245       return -ENODEV;
 246     }
 247
 248     int DisUpdateService(unsigned int id) const {
 249       if (fpDisUpdateService) return (*fpDisUpdateService)(id);
 250       return -ENODEV;
 251     }
 252
 253     int DisStartServing(const char *server) const {
 254       if (fpDisStartServing) return (*fpDisStartServing)(server);
 255       return -ENODEV;
 256     }
 257
 258     int DisStopServing() const {
 259       if (fpDisStopServing) return (*fpDisStopServing)();
 260       return -ENODEV;
 261     }
 262
 263     int DisSetDnsNode(const char *server) const {
 264       if (fpDisSetDnsNode) return (*fpDisSetDnsNode)(server);
 265       return -ENODEV;
 266     }
 267
 268   private:
 269     fctVoid FindSymbol(const char* library, const char* symbol) const;
 270
 271     fctDisAddService      fpDisAddService;      //! transient
 272     fctDisRemoveService   fpDisRemoveService;   //! transient
 273     fctDisUpdateService   fpDisUpdateService;   //! transient
 274     fctDisCharArg         fpDisStartServing;    //! transient
 275     fctDisNoArg           fpDisStopServing;     //! transient
 276     fctDisCharArg         fpDisSetDnsNode;      //! transient
 277     static const char*    fgkDimLibraryName  ;       //!
 278     static const char*    fgkDisAddServiceSymbol;    //!
 279     static const char*    fgkDisRemoveServiceSymbol;    //!
 280     static const char*    fgkDisUpdateServiceSymbol; //!
 281     static const char*    fgkDisStartServingSymbol;  //!
 282     static const char*    fgkDisStopServingSymbol;  //!
 283     static const char*    fgkDisSetDnsNodeSymbol;  //!
 284   };
 285
 286   static AliHLTDimInterface* Interface();
 287
 288 private:
 289   /// copy constructor not permitted
 290   AliHLTDimServer(const AliHLTDimServer&);
 291   /// assignment operator not permitted
 292   AliHLTDimServer& operator=(const AliHLTDimServer&);
 293
 294   /// entry point for the thread, param is pointer to object
 295   static void* ServerLoop(void* param);
 296
 297   /// the server loop
 298   void* ServerLoop();
 299
 300   TObjArray fServices; //! list of services
 301   int fState; //! state of the server
 302   TThread* fpServerThread; //! thread
 303   int fUpdatePeriod; //! update period for the DIM loop in ms
 304
 305   static AliHLTDimInterface* fgpInterface; //! the dim interface
 306
 307   ClassDef(AliHLTDimServer, 0)
 308 };
 309 #endif