1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/*
Copyright (C) 2009 Her Majesty the Queen in Right of Canada (Communications
Research Center Canada)
Copyright (C) 2018
Matthias P. Braendli, matthias.braendli@mpb.li
http://www.opendigitalradio.org
A server that serves state information and statistics for
monitoring purposes, and also serves the internal configuration
property tree.
This statistics server is very easy to integrate with munin
http://munin-monitoring.org/
but is not specific to it.
The responds in JSON, and accepts the commands:
- config
- values
Inspired by the munin equivalent, returns the configuration
and the statistics values for every exported stat.
- getptree
Returns the internal boost property_tree that contains the
multiplexer configuration DB.
The server is using REQ/REP ZeroMQ sockets.
*/
/*
This file is part of ODR-DabMux.
ODR-DabMux is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
ODR-DabMux is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with ODR-DabMux. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "zmq.hpp"
#include <string>
#include <map>
#include <atomic>
#include <chrono>
#include <deque>
#include <thread>
#include <mutex>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <cmath>
/*** State handing ***/
/* An input can be in one of the following three states:
*/
enum class input_state_t
{
/* The input is waiting for data, all buffers are empty */
NoData,
/* The input is running, but has seen many underruns or overruns recently */
Unstable,
/* The input is running, but the audio level is too low, or has
* been too low recently
*/
Silence,
/* The input is running stable */
Streaming
};
/* InputStat takes care of
* - saving the statistics for graphing
* - calculating the state of the input for monitoring
*/
class InputStat
{
public:
InputStat(const std::string& name);
InputStat(const InputStat& other) = delete;
InputStat& operator=(const InputStat& other) = delete;
~InputStat();
void registerAtServer(void);
std::string get_name(void) const { return m_name; }
/* This function is called for every frame read by
* the multiplexer */
void notifyBuffer(long bufsize);
void notifyPeakLevels(int peak_left, int peak_right);
void notifyUnderrun(void);
void notifyOverrun(void);
std::string encodeValuesJSON(void);
input_state_t determineState(void);
private:
std::string m_name;
/************ STATISTICS ***********/
// Keep track of buffer fill with timestamps, so that we
// can calculate the correct state from it.
struct fill_stat_t {
std::chrono::time_point<std::chrono::steady_clock> timestamp;
long bufsize;
};
std::deque<fill_stat_t> m_buffer_fill_stats;
// counter of number of overruns and underruns since startup
uint32_t m_num_underruns = 0;
uint32_t m_num_overruns = 0;
// Peak audio levels (linear 16-bit PCM) for the two channels.
// Keep a FIFO of values from the last minutes, apply
// a short window to also see short-term fluctuations.
struct peak_stat_t {
std::chrono::time_point<std::chrono::steady_clock> timestamp;
int peak_left;
int peak_right;
};
std::deque<peak_stat_t> m_peak_stats;
size_t m_short_window_length = 0;
/************* STATE ***************/
/* Variables used for determining the input state */
int m_glitch_counter = 0; // saturating counter
int m_silence_counter = 0; // saturating counter
std::chrono::time_point<std::chrono::steady_clock> m_time_last_event;
// The mutex that has to be held during all notify and readout
mutable std::mutex m_mutex;
};
class ManagementServer
{
public:
ManagementServer();
ManagementServer(const ManagementServer& other) = delete;
ManagementServer& operator=(const ManagementServer& other) = delete;
~ManagementServer();
void open(int listenport);
/* Un-/Register a statistics data source */
void registerInput(InputStat* is);
void unregisterInput(std::string id);
/* Load a ptree given by the management server.
*
* Returns true if the ptree was updated
*/
bool retrieve_new_ptree(boost::property_tree::ptree& pt);
/* Update the copy of the configuration property tree and notify the
* update to the internal server thread.
*/
void update_ptree(const boost::property_tree::ptree& pt);
bool fault_detected() const { return m_fault; }
void restart(void);
private:
void restart_thread(long);
/******* Server ******/
zmq::context_t m_zmq_context;
zmq::socket_t m_zmq_sock;
void serverThread(void);
void handle_message(zmq::message_t& zmq_message);
bool isInputRegistered(std::string& id);
int m_listenport = 0;
// serverThread runs in a separate thread
std::atomic<bool> m_running;
std::atomic<bool> m_fault;
std::thread m_thread;
std::thread m_restarter_thread;
/******* Statistics Data ********/
std::map<std::string, InputStat*> m_inputStats;
/* Return a description of the configuration that will
* allow to define what graphs to be created
*
* returns: a JSON encoded configuration
*/
std::string getStatConfigJSON();
/* Return the values for the statistics as defined in the configuration
*
* returns: JSON encoded statistics
*/
std::string getValuesJSON();
// mutex for accessing the map
std::mutex m_statsmutex;
/******** Configuration Data *******/
std::mutex m_configmutex;
boost::property_tree::ptree m_pt;
};
// If necessary construct the management server singleton and return
// a reference to it
ManagementServer& get_mgmt_server();
|
