Line data Source code
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 0 : 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 0 : AliHLTDimServiceDataType GetType() const {return fType;}
100 0 : const char* GetTypeString() const { return fTypeString.Data(); }
101 0 : void* GetLocation() {return fDataBuffer;}
102 0 : int GetId() const {return fId;}
103 0 : int SetId(int id) {fId=id;return id;}
104 : void* GetDataBuffer() const { return fDataBuffer; }
105 0 : 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 0 : int SetState(int state) {fState=state; return fState;}
204 :
205 0 : 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 0 : if (fpDisAddService) return (*fpDisAddService)(service, type, buffer, size, NULL, 0);
240 0 : return -ENODEV;
241 0 : }
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 0 : if (fpDisUpdateService) return (*fpDisUpdateService)(id);
250 0 : return -ENODEV;
251 0 : }
252 :
253 : int DisStartServing(const char *server) const {
254 0 : if (fpDisStartServing) return (*fpDisStartServing)(server);
255 0 : return -ENODEV;
256 0 : }
257 :
258 : int DisStopServing() const {
259 0 : if (fpDisStopServing) return (*fpDisStopServing)();
260 0 : return -ENODEV;
261 0 : }
262 :
263 : int DisSetDnsNode(const char *server) const {
264 0 : if (fpDisSetDnsNode) return (*fpDisSetDnsNode)(server);
265 0 : return -ENODEV;
266 0 : }
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 126 : ClassDef(AliHLTDimServer, 0)
308 : };
309 : #endif
|
