napa-baselibs / monl / measure_manager.h @ 507372bb
History | View | Annotate | Download (8.55 KB)
1 |
/***************************************************************************
|
---|---|
2 |
* Copyright (C) 2009 by Robert Birke
|
3 |
* robert.birke@polito.it
|
4 |
*
|
5 |
* This library is free software; you can redistribute it and/or
|
6 |
* modify it under the terms of the GNU Lesser General Public
|
7 |
* License as published by the Free Software Foundation; either
|
8 |
* version 2.1 of the License, or (at your option) any later version.
|
9 |
|
10 |
* This library is distributed in the hope that it will be useful,
|
11 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
12 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
13 |
* Lesser General Public License for more details.
|
14 |
|
15 |
* You should have received a copy of the GNU Lesser General Public
|
16 |
* License along with this library; if not, write to the Free Software
|
17 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
18 |
***********************************************************************/
|
19 |
|
20 |
#ifndef _MEASURE_MANAGER_H
|
21 |
#define _MEASURE_MANAGER_H
|
22 |
|
23 |
#include <string> |
24 |
#include <map> |
25 |
#include "mon_measure.h" |
26 |
#include "measure_plugin.h" |
27 |
#include "measure_dispatcher.h" |
28 |
|
29 |
#include "napa_log.h" |
30 |
|
31 |
|
32 |
#define MAX_NUM_MEASURES_INSTANTIATED 1000000 |
33 |
|
34 |
typedef std::map<MeasurementId, class MeasurePlugin *> MonMeasureMapId;
|
35 |
typedef std::map<std::string, class MeasurePlugin *> MonMeasureMapName;
|
36 |
typedef std::map<MonHandler,class MonMeasure *> MeasureMap;
|
37 |
|
38 |
class MeasureManager { |
39 |
protected:
|
40 |
/* List of available measures */
|
41 |
MonMeasureMapId mMonMeasuresId; |
42 |
MonMeasureMapName mMonMeasuresName; |
43 |
|
44 |
/* defualts */
|
45 |
void *default_repo_client;
|
46 |
char* default_channel;
|
47 |
char** peer_name;
|
48 |
|
49 |
class MeasureDispatcher cDispatcher; |
50 |
|
51 |
/* Currently installed instances */
|
52 |
MeasureMap mMeasureInstances; |
53 |
int next_measure_handler;
|
54 |
|
55 |
/* Used to load a MeasurePlugin. If the Id or name has been already used it returns a negative value, *
|
56 |
* 0 otherwise. */
|
57 |
int loadMeasurePlugin(MeasurePlugin *plugin) {
|
58 |
if(mMonMeasuresId.find(plugin->getId()) == mMonMeasuresId.end() &&
|
59 |
mMonMeasuresName.find(plugin->getName()) == mMonMeasuresName.end()) |
60 |
{ |
61 |
mMonMeasuresId[plugin->getId()] = plugin; |
62 |
mMonMeasuresName[plugin->getName()] = plugin; |
63 |
return EOK;
|
64 |
} else
|
65 |
return -EINVAL;
|
66 |
}; |
67 |
|
68 |
int loadMeasurePlugins(void); |
69 |
|
70 |
/* Inserts new instance. Returns handler */
|
71 |
MonHandler insertNewInstance(MonMeasure *m) { |
72 |
int new_mh;
|
73 |
/* For memory efficiency we use a hash container and a circular buffer */
|
74 |
/* check if next_measure_handler is not in use (went around once) */
|
75 |
if(mMeasureInstances.find(next_measure_handler) != mMeasureInstances.end())
|
76 |
return -ENOMEM;
|
77 |
new_mh = next_measure_handler; |
78 |
mMeasureInstances[new_mh] = m; |
79 |
|
80 |
/* update next_measure_handler */
|
81 |
next_measure_handler++; |
82 |
if(next_measure_handler == MAX_NUM_MEASURES_INSTANTIATED)
|
83 |
next_measure_handler = 0;
|
84 |
|
85 |
return new_mh;
|
86 |
} |
87 |
/* checks handler */
|
88 |
bool isValidMonHandler(MonHandler mh) {
|
89 |
if(mMeasureInstances.find(mh) != mMeasureInstances.end())
|
90 |
return true; |
91 |
else
|
92 |
return false; |
93 |
} |
94 |
|
95 |
friend class MonMeasure; |
96 |
friend class MeasureDispatcher; |
97 |
public:
|
98 |
/* Constructor */
|
99 |
MeasureManager() { |
100 |
default_repo_client = NULL;
|
101 |
default_channel = NULL;
|
102 |
next_measure_handler = 0;
|
103 |
cDispatcher.mm = this; |
104 |
peer_name = new char*;
|
105 |
*peer_name = NULL;
|
106 |
loadMeasurePlugins(); |
107 |
}; |
108 |
|
109 |
MeasureManager(void *repo) {
|
110 |
default_repo_client = repo; |
111 |
default_channel = NULL;
|
112 |
next_measure_handler = 0;
|
113 |
cDispatcher.mm = this; |
114 |
peer_name = new char*;
|
115 |
*peer_name = NULL;
|
116 |
loadMeasurePlugins(); |
117 |
}; |
118 |
|
119 |
/* Destructor */
|
120 |
~MeasureManager() { |
121 |
/* Free list of available measures */
|
122 |
for(MonMeasureMapId::reverse_iterator it = mMonMeasuresId.rbegin();
|
123 |
it !=mMonMeasuresId.rend(); ++it) |
124 |
delete it->second; |
125 |
/* Free instances */
|
126 |
for(MeasureMap::iterator it = mMeasureInstances.begin();
|
127 |
it != mMeasureInstances.end(); ++it) |
128 |
monDestroyMeasure(it->first); |
129 |
if(default_channel)
|
130 |
delete[] default_channel; |
131 |
if(*peer_name != NULL) |
132 |
delete[] *peer_name; |
133 |
delete peer_name; |
134 |
} |
135 |
|
136 |
/* Returns a map container with all the measures which can be instantiated and used */
|
137 |
MonMeasureMapId& monListMeasure() { |
138 |
return mMonMeasuresId;
|
139 |
}; |
140 |
|
141 |
/* Creates an instance of a measure specified through the name of the measure
|
142 |
* returns handler of the new instance to be used subsequently with the functions below */
|
143 |
int monCreateMeasureName(MeasurementName name, MeasurementCapabilities mc) {
|
144 |
std::string t(name); |
145 |
MonMeasure *m; |
146 |
int ret;
|
147 |
MonHandler mh; |
148 |
|
149 |
if(mMonMeasuresName.find(t) == mMonMeasuresName.end())
|
150 |
return -EINVAL;
|
151 |
|
152 |
if(!(mc & REMOTE))
|
153 |
mc |= (mMonMeasuresName[t]->getCaps() & TXRXBI); |
154 |
|
155 |
m = mMonMeasuresName[t]->createMeasure(mc, &cDispatcher); |
156 |
|
157 |
ret = m->setFlags(mc); |
158 |
if(ret != EOK)
|
159 |
goto error;
|
160 |
|
161 |
ret = mh = insertNewInstance(m); |
162 |
if(mh < 0) |
163 |
goto error;
|
164 |
|
165 |
m->mh_local = mh; |
166 |
return mh;
|
167 |
|
168 |
error:
|
169 |
delete m; |
170 |
return ret;
|
171 |
}; |
172 |
|
173 |
int monCreateMeasureId(MeasurementId id, MeasurementCapabilities mc) {
|
174 |
MonMeasure *m; |
175 |
int ret;
|
176 |
MonHandler mh; |
177 |
|
178 |
if(mMonMeasuresId.find(id) == mMonMeasuresId.end())
|
179 |
return -EINVAL;
|
180 |
|
181 |
if(!(mc & REMOTE))
|
182 |
mc |= (mMonMeasuresId[id]->getCaps() & TXRXBI); |
183 |
|
184 |
m = mMonMeasuresId[id]->createMeasure(mc, &cDispatcher); |
185 |
|
186 |
ret = m->setFlags(mc); |
187 |
if(ret != EOK)
|
188 |
goto error;
|
189 |
|
190 |
ret = mh = insertNewInstance(m); |
191 |
if(mh < 0) |
192 |
goto error;
|
193 |
|
194 |
m->mh_local = mh; |
195 |
|
196 |
return mh;
|
197 |
|
198 |
error:
|
199 |
delete m; |
200 |
return ret;
|
201 |
}; |
202 |
|
203 |
/* Destroys a specific measure instance */
|
204 |
int monDestroyMeasure(MonHandler mh) {
|
205 |
/* find it */
|
206 |
if(!isValidMonHandler(mh))
|
207 |
return -EINVAL;
|
208 |
|
209 |
/* deactivate it */
|
210 |
cDispatcher.deactivateMeasure(mMeasureInstances[mh]); |
211 |
|
212 |
delete mMeasureInstances[mh]; |
213 |
mMeasureInstances.erase(mh); |
214 |
|
215 |
return EOK;
|
216 |
}; |
217 |
|
218 |
MeasurementId monMeasureHandlerToId (MonHandler mh) { |
219 |
/* find it */
|
220 |
if(!isValidMonHandler(mh))
|
221 |
return -EINVAL;
|
222 |
|
223 |
return mMeasureInstances[mh]->measure_plugin->getId();
|
224 |
} |
225 |
|
226 |
std::vector<class MonParameter *>* monListParameters(MonHandler mh) { |
227 |
if(!isValidMonHandler(mh))
|
228 |
return NULL; |
229 |
return &(mMeasureInstances[mh]->listParameters());
|
230 |
}; |
231 |
|
232 |
int monSetParameter(MonHandler mh, int pid, MonParameterValue p) { |
233 |
if(!isValidMonHandler(mh))
|
234 |
return -EINVAL;
|
235 |
return mMeasureInstances[mh]->setParameter(pid,p);
|
236 |
}; |
237 |
|
238 |
MonParameterValue monGetParameter(MonHandler mh, size_t pid) { |
239 |
if(!isValidMonHandler(mh))
|
240 |
return NAN;
|
241 |
return mMeasureInstances[mh]->getParameter(pid);
|
242 |
}; |
243 |
|
244 |
MeasurementStatus monGetStatus(MonHandler mh) { |
245 |
if(!isValidMonHandler(mh))
|
246 |
return MS_ERROR;
|
247 |
return mMeasureInstances[mh]->getStatus();
|
248 |
}; |
249 |
|
250 |
MeasurementCapabilities monGetMeasurementCaps(MonHandler mh) { |
251 |
if(!isValidMonHandler(mh))
|
252 |
return -EINVAL;
|
253 |
return mMeasureInstances[mh]->getFlags();
|
254 |
} |
255 |
|
256 |
int monActivateMeasure(MonHandler mh, SocketId sid, MsgType mt) {
|
257 |
if(!isValidMonHandler(mh))
|
258 |
return -EINVAL;
|
259 |
return cDispatcher.activateMeasure(mMeasureInstances[mh], sid, mt);
|
260 |
} |
261 |
|
262 |
int monDeactivateMeasure(MonHandler mh) {
|
263 |
if(!isValidMonHandler(mh))
|
264 |
return -EINVAL;
|
265 |
return cDispatcher.deactivateMeasure(mMeasureInstances[mh]);
|
266 |
} |
267 |
|
268 |
size_t getMeasuresCount(void) {
|
269 |
return mMonMeasuresId.size();
|
270 |
}; |
271 |
|
272 |
void cbRxPkt(void *arg) { |
273 |
cDispatcher.cbRxPkt(arg); |
274 |
}; |
275 |
|
276 |
void cbRxData(void *arg) { |
277 |
cDispatcher.cbRxData(arg); |
278 |
}; |
279 |
|
280 |
void cbTxPkt(void *arg) { |
281 |
cDispatcher.cbTxPkt(arg); |
282 |
}; |
283 |
|
284 |
void cbTxData(void *arg) { |
285 |
cDispatcher.cbTxData(arg); |
286 |
}; |
287 |
|
288 |
int cbHdrPkt(SocketId sid, MsgType mt) {
|
289 |
return cDispatcher.cbHdrPkt(sid, mt);
|
290 |
}; |
291 |
|
292 |
int cbHdrData(SocketId sid, MsgType mt) {
|
293 |
return cDispatcher.cbHdrData(sid, mt);
|
294 |
}; |
295 |
|
296 |
void receiveCtrlMsg(SocketId sid, MsgType mt, char *buffer, int buflen){ |
297 |
cDispatcher.receiveCtrlMsg(sid, mt, buffer, buflen); |
298 |
}; |
299 |
|
300 |
int monPublishStatisticalType(MonHandler mh, const char* publishing_name, const char *channel, enum stat_types st[], int length, void *repo_client) { |
301 |
if(repo_client == NULL) |
302 |
repo_client = default_repo_client; |
303 |
|
304 |
if(repo_client == NULL) |
305 |
return -EFAILED;
|
306 |
|
307 |
if(channel == NULL) |
308 |
channel = default_channel; |
309 |
|
310 |
if(!isValidMonHandler(mh))
|
311 |
return -EINVAL;
|
312 |
|
313 |
return mMeasureInstances[mh]->setPublishStatisticalType(publishing_name, channel, st, length, repo_client);
|
314 |
}; |
315 |
|
316 |
result monRetrieveResult(MonHandler mh, enum stat_types st) {
|
317 |
if(!isValidMonHandler(mh))
|
318 |
return NAN;
|
319 |
|
320 |
if(mMeasureInstances[mh]->rb == NULL) |
321 |
return NAN;
|
322 |
|
323 |
mMeasureInstances[mh]->rb->updateStats(); |
324 |
return mMeasureInstances[mh]->rb->stats[st];
|
325 |
}; |
326 |
|
327 |
int monNewSample(MonHandler mh, result r) {
|
328 |
if(!isValidMonHandler(mh))
|
329 |
return -EINVAL;
|
330 |
|
331 |
if(mMeasureInstances[mh]->flags != 0) |
332 |
return -EINVAL;
|
333 |
|
334 |
return mMeasureInstances[mh]->newSample(r);
|
335 |
}; |
336 |
|
337 |
void monParseConfig(void *); |
338 |
|
339 |
int monSetPeerName(const char *pn); |
340 |
}; |
341 |
|
342 |
#endif /* _MEASURE_MANAGER_H */ |