14 #include <boost/make_shared.hpp> 27 StatsMgr::instance() {
32 StatsMgr::StatsMgr() :
33 global_(boost::make_shared<StatContext>()), mutex_(
new mutex) {
37 StatsMgr::setValue(
const string& name,
const int64_t value) {
38 if (MultiThreadingMgr::instance().getMode()) {
39 lock_guard<mutex> lock(*mutex_);
40 setValueInternal(name, value);
42 setValueInternal(name, value);
47 StatsMgr::setValue(
const string& name,
const double value) {
48 if (MultiThreadingMgr::instance().getMode()) {
49 lock_guard<mutex> lock(*mutex_);
50 setValueInternal(name, value);
52 setValueInternal(name, value);
58 if (MultiThreadingMgr::instance().getMode()) {
59 lock_guard<mutex> lock(*mutex_);
60 setValueInternal(name, value);
62 setValueInternal(name, value);
67 StatsMgr::setValue(
const string& name,
const string& value) {
68 if (MultiThreadingMgr::instance().getMode()) {
69 lock_guard<mutex> lock(*mutex_);
70 setValueInternal(name, value);
72 setValueInternal(name, value);
77 StatsMgr::addValue(
const string& name,
const int64_t value) {
78 if (MultiThreadingMgr::instance().getMode()) {
79 lock_guard<mutex> lock(*mutex_);
80 addValueInternal(name, value);
82 addValueInternal(name, value);
87 StatsMgr::addValue(
const string& name,
const double value) {
88 if (MultiThreadingMgr::instance().getMode()) {
89 lock_guard<mutex> lock(*mutex_);
90 addValueInternal(name, value);
92 addValueInternal(name, value);
98 if (MultiThreadingMgr::instance().getMode()) {
99 lock_guard<mutex> lock(*mutex_);
100 addValueInternal(name, value);
102 addValueInternal(name, value);
107 StatsMgr::addValue(
const string& name,
const string& value) {
108 if (MultiThreadingMgr::instance().getMode()) {
109 lock_guard<mutex> lock(*mutex_);
110 addValueInternal(name, value);
112 addValueInternal(name, value);
117 StatsMgr::getObservation(
const string& name)
const {
118 if (MultiThreadingMgr::instance().getMode()) {
119 lock_guard<mutex> lock(*mutex_);
120 return (getObservationInternal(name));
122 return (getObservationInternal(name));
127 StatsMgr::getObservationInternal(
const string& name)
const {
130 return (global_->get(name));
135 if (MultiThreadingMgr::instance().getMode()) {
136 lock_guard<mutex> lock(*mutex_);
137 addObservationInternal(stat);
139 addObservationInternal(stat);
151 StatsMgr::deleteObservation(
const string& name) {
152 if (MultiThreadingMgr::instance().getMode()) {
153 lock_guard<mutex> lock(*mutex_);
154 return (deleteObservationInternal(name));
156 return (deleteObservationInternal(name));
161 StatsMgr::deleteObservationInternal(
const string& name) {
164 return (global_->del(name));
168 StatsMgr::setMaxSampleAge(
const string& name,
const StatsDuration& duration) {
169 if (MultiThreadingMgr::instance().getMode()) {
170 lock_guard<mutex> lock(*mutex_);
171 return (setMaxSampleAgeInternal(name, duration));
173 return (setMaxSampleAgeInternal(name, duration));
178 StatsMgr::setMaxSampleAgeInternal(
const string& name,
182 obs->setMaxSampleAge(duration);
189 StatsMgr::setMaxSampleCount(
const string& name, uint32_t max_samples) {
190 if (MultiThreadingMgr::instance().getMode()) {
191 lock_guard<mutex> lock(*mutex_);
192 return (setMaxSampleCountInternal(name, max_samples));
194 return (setMaxSampleCountInternal(name, max_samples));
199 StatsMgr::setMaxSampleCountInternal(
const string& name,
200 uint32_t max_samples) {
203 obs->setMaxSampleCount(max_samples);
211 if (MultiThreadingMgr::instance().getMode()) {
212 lock_guard<mutex> lock(*mutex_);
213 setMaxSampleAgeAllInternal(duration);
215 setMaxSampleAgeAllInternal(duration);
220 StatsMgr::setMaxSampleAgeAllInternal(
const StatsDuration& duration) {
221 global_->setMaxSampleAgeAll(duration);
225 StatsMgr::setMaxSampleCountAll(uint32_t max_samples) {
226 if (MultiThreadingMgr::instance().getMode()) {
227 lock_guard<mutex> lock(*mutex_);
228 setMaxSampleCountAllInternal(max_samples);
230 setMaxSampleCountAllInternal(max_samples);
235 StatsMgr::setMaxSampleCountAllInternal(uint32_t max_samples) {
236 global_->setMaxSampleCountAll(max_samples);
241 if (MultiThreadingMgr::instance().getMode()) {
242 lock_guard<mutex> lock(*mutex_);
243 setMaxSampleAgeDefaultInternal(duration);
245 setMaxSampleAgeDefaultInternal(duration);
250 StatsMgr::setMaxSampleAgeDefaultInternal(
const StatsDuration& duration) {
251 Observation::setMaxSampleAgeDefault(duration);
255 StatsMgr::setMaxSampleCountDefault(uint32_t max_samples) {
256 if (MultiThreadingMgr::instance().getMode()) {
257 lock_guard<mutex> lock(*mutex_);
258 setMaxSampleCountDefaultInternal(max_samples);
260 setMaxSampleCountDefaultInternal(max_samples);
265 StatsMgr::setMaxSampleCountDefaultInternal(uint32_t max_samples) {
266 Observation::setMaxSampleCountDefault(max_samples);
270 StatsMgr::getMaxSampleAgeDefault()
const {
271 if (MultiThreadingMgr::instance().getMode()) {
272 lock_guard<mutex> lock(*mutex_);
273 return (getMaxSampleAgeDefaultInternal());
275 return (getMaxSampleAgeDefaultInternal());
280 StatsMgr::getMaxSampleAgeDefaultInternal()
const {
281 return (Observation::getMaxSampleAgeDefault());
285 StatsMgr::getMaxSampleCountDefault()
const {
286 if (MultiThreadingMgr::instance().getMode()) {
287 lock_guard<mutex> lock(*mutex_);
288 return (getMaxSampleCountDefaultInternal());
290 return (getMaxSampleCountDefaultInternal());
295 StatsMgr::getMaxSampleCountDefaultInternal()
const {
296 return (Observation::getMaxSampleCountDefault());
300 StatsMgr::reset(
const string& name) {
301 if (MultiThreadingMgr::instance().getMode()) {
302 lock_guard<mutex> lock(*mutex_);
303 return (resetInternal(name));
305 return (resetInternal(name));
310 StatsMgr::resetInternal(
const string& name) {
320 StatsMgr::del(
const string& name) {
321 if (MultiThreadingMgr::instance().getMode()) {
322 lock_guard<mutex> lock(*mutex_);
323 return (delInternal(name));
325 return (delInternal(name));
330 StatsMgr::delInternal(
const string& name) {
331 return (global_->del(name));
335 StatsMgr::removeAll() {
336 if (MultiThreadingMgr::instance().getMode()) {
337 lock_guard<mutex> lock(*mutex_);
345 StatsMgr::removeAllInternal() {
350 StatsMgr::get(
const string& name)
const {
351 if (MultiThreadingMgr::instance().getMode()) {
352 lock_guard<mutex> lock(*mutex_);
353 return (getInternal(name));
355 return (getInternal(name));
360 StatsMgr::getInternal(
const string& name)
const {
364 map->set(name, obs->getJSON());
370 StatsMgr::getAll()
const {
371 if (MultiThreadingMgr::instance().getMode()) {
372 lock_guard<mutex> lock(*mutex_);
373 return (getAllInternal());
375 return (getAllInternal());
380 StatsMgr::getAllInternal()
const {
381 return (global_->getAll());
385 StatsMgr::resetAll() {
386 if (MultiThreadingMgr::instance().getMode()) {
387 lock_guard<mutex> lock(*mutex_);
395 StatsMgr::resetAllInternal() {
400 StatsMgr::getSize(
const string& name)
const {
401 if (MultiThreadingMgr::instance().getMode()) {
402 lock_guard<mutex> lock(*mutex_);
403 return (getSizeInternal(name));
405 return (getSizeInternal(name));
410 StatsMgr::getSizeInternal(
const string& name)
const {
413 return (obs->getSize());
419 StatsMgr::count()
const {
420 if (MultiThreadingMgr::instance().getMode()) {
421 lock_guard<mutex> lock(*mutex_);
422 return (countInternal());
424 return (countInternal());
429 StatsMgr::countInternal()
const {
430 return (global_->size());
434 StatsMgr::statisticSetMaxSampleAgeHandler(
const string& ,
438 if (!StatsMgr::getStatName(params, name, error)) {
441 if (!StatsMgr::getStatDuration(params, duration, error)) {
444 if (StatsMgr::instance().setMaxSampleAge(name, duration)) {
446 "Statistic '" + name +
"' duration limit is set."));
449 "No '" + name +
"' statistic found"));
454 StatsMgr::statisticSetMaxSampleCountHandler(
const string& ,
457 uint32_t max_samples;
458 if (!StatsMgr::getStatName(params, name, error)) {
461 if (!StatsMgr::getStatMaxSamples(params, max_samples, error)) {
464 if (StatsMgr::instance().setMaxSampleCount(name, max_samples)) {
466 "Statistic '" + name +
"' count limit is set."));
469 "No '" + name +
"' statistic found"));
474 StatsMgr::statisticGetHandler(
const string& ,
477 if (!StatsMgr::getStatName(params, name, error)) {
481 StatsMgr::instance().
get(name)));
485 StatsMgr::statisticResetHandler(
const string& ,
488 if (!StatsMgr::getStatName(params, name, error)) {
491 if (StatsMgr::instance().reset(name)) {
493 "Statistic '" + name +
"' reset."));
496 "No '" + name +
"' statistic found"));
501 StatsMgr::statisticRemoveHandler(
const string& ,
504 if (!StatsMgr::getStatName(params, name, error)) {
507 if (StatsMgr::instance().del(name)) {
509 "Statistic '" + name +
"' removed."));
512 "No '" + name +
"' statistic found"));
518 StatsMgr::statisticRemoveAllHandler(
const string& ,
520 StatsMgr::instance().removeAll();
522 "Warning: statistic-remove-all command is deprecated." 523 " All statistics removed."));
527 StatsMgr::statisticGetAllHandler(
const string& ,
534 StatsMgr::statisticResetAllHandler(
const string& ,
536 StatsMgr::instance().resetAll();
538 "All statistics reset to neutral values."));
545 if (!StatsMgr::getStatDuration(params, duration, error)) {
548 if (MultiThreadingMgr::instance().getMode()) {
549 lock_guard<mutex> lock(*mutex_);
550 StatsMgr::instance().setMaxSampleCountDefaultInternal(0);
551 StatsMgr::instance().setMaxSampleAgeDefaultInternal(duration);
552 StatsMgr::instance().setMaxSampleAgeAllInternal(duration);
554 StatsMgr::instance().setMaxSampleCountDefaultInternal(0);
555 StatsMgr::instance().setMaxSampleAgeDefaultInternal(duration);
556 StatsMgr::instance().setMaxSampleAgeAllInternal(duration);
559 "All statistics duration limit are set."));
565 uint32_t max_samples;
566 if (!StatsMgr::getStatMaxSamples(params, max_samples, error)) {
569 if (max_samples == 0) {
570 error =
"'max-samples' parameter must not be zero";
573 if (MultiThreadingMgr::instance().getMode()) {
574 lock_guard<mutex> lock(*mutex_);
575 StatsMgr::instance().setMaxSampleCountDefaultInternal(max_samples);
576 StatsMgr::instance().setMaxSampleCountAllInternal(max_samples);
578 StatsMgr::instance().setMaxSampleCountDefaultInternal(max_samples);
579 StatsMgr::instance().setMaxSampleCountAllInternal(max_samples);
582 "All statistics count limit are set."));
590 reason =
"Missing mandatory 'name' parameter.";
595 reason =
"Missing mandatory 'name' parameter.";
598 if (stat_name->getType() != Element::string) {
599 reason =
"'name' parameter expected to be a string.";
602 name = stat_name->stringValue();
611 reason =
"Missing mandatory 'duration' parameter.";
615 if (!stat_duration) {
616 reason =
"Missing mandatory 'duration' parameter.";
619 duration = std::chrono::seconds(stat_duration->intValue());
625 uint32_t& max_samples,
628 reason =
"Missing mandatory 'max-samples' parameter.";
632 if (!stat_max_samples) {
633 reason =
"Missing mandatory 'max-samples' parameter.";
636 if (stat_max_samples->getType() != Element::integer) {
637 reason =
"'max-samples' parameter expected to be an integer.";
640 max_samples = stat_max_samples->intValue();
ConstElementPtr createAnswer(const int status_code, const std::string &text, const ConstElementPtr &arg)
const int CONTROL_RESULT_SUCCESS
Status code indicating a successful operation.
const int CONTROL_RESULT_ERROR
Status code indicating a general failure.
boost::shared_ptr< Element > ElementPtr
Statistics Manager class.
std::chrono::system_clock::duration StatsDuration
Defines duration type.
boost::shared_ptr< const Element > ConstElementPtr
Defines the logger used by the top-level component of kea-lfc.
This file contains several functions and constants that are used for handling commands and responses ...
boost::shared_ptr< Observation > ObservationPtr
Observation pointer.