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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
|
# -*- coding: utf-8 -*-
#
# This file is part of Glances.
#
# Copyright (C) 2014 Nicolargo <nicolas@nicolargo.com>
#
# Glances is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Glances 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
I am your father...
For all Glances plugins
"""
# Import system libs
import json
# Import Glances lib
from glances.core.glances_globals import glances_logs
class GlancesPlugin(object):
"""
Main class for Glances' plugin
"""
def __init__(self, args=None):
# Plugin name (= module name without glances_)
self.plugin_name = self.__class__.__module__[len('glances_'):]
# Init the args
self.args = args
# Init the input method
self.input_method = 'local'
# Init the stats list
self.stats = None
# Init the limits dictionnary
self.limits = dict()
def __repr__(self):
# Return the raw stats
return self.stats
def __str__(self):
# Return the human-readable stats
return str(self.stats)
def set_input(self, input_method):
"""
Set the input method:
* local: system local grab (PSUtil or direct access)
* snmp: Client server mode via SNMP
* glances: Client server mode via Glances API
"""
self.input_method = input_method
return self.input_method
def get_input(self):
"""
Get the input method
"""
return self.input_method
def set_stats(self, input_stats):
# Set the stats to input_stats
self.stats = input_stats
return self.stats
def set_stats_snmp(self, bulk=False, snmp_oid={}):
# Update stats using SNMP
# If bulk=True, use a bulk request instead of a get request
from glances.core.glances_snmp import GlancesSNMPClient
# Init the SNMP request
clientsnmp = GlancesSNMPClient(host=self.args.client,
port=self.args.snmp_port,
version=self.args.snmp_version,
community=self.args.snmp_community)
# Process the SNMP request
ret = {}
if bulk:
# Bulk request
snmpresult = clientsnmp.getbulk_by_oid(0, 10, *snmp_oid.values())
# Build the internal dict with the SNMP result
# key is the first item in the snmp_oid
index = 1
for item in snmpresult:
item_stats = {}
item_key = None
for key in snmp_oid.iterkeys():
oid = snmp_oid[key] + '.' + str(index)
if oid in item:
if item_key is None:
item_key = item[oid]
else:
item_stats[key] = item[oid]
if item_stats != {}:
ret[item_key] = item_stats
index += 1
else:
# Simple get request
snmpresult = clientsnmp.get_by_oid(*snmp_oid.values())
# Build the internal dict with the SNMP result
for key in snmp_oid.iterkeys():
ret[key] = snmpresult[snmp_oid[key]]
return ret
def get_raw(self):
# Return the stats object
return self.stats
def get_stats(self):
# Return the stats object in JSON format for the RPC API
return json.dumps(self.stats)
def load_limits(self, config):
"""
Load the limits from the configuration file
"""
if (hasattr(config, 'has_section') and
config.has_section(self.plugin_name)):
# print "Load limits for %s" % self.plugin_name
for s, v in config.items(self.plugin_name):
# Read limits
# print "\t%s = %s" % (self.plugin_name + '_' + s, v)
try:
self.limits[self.plugin_name + '_' + s] = config.get_option(self.plugin_name, s)
except ValueError:
self.limits[self.plugin_name + '_' + s] = config.get_raw_option(self.plugin_name, s).split(",")
def set_limits(self, input_limits):
# Set the limits to input_limits
self.limits = input_limits
return self.limits
def get_limits(self):
# Return the limits object
return self.limits
def get_alert(self, current=0, min=0, max=100, header="", log=False):
# Return the alert status relative to a current value
# Use this function for minor stat
# If current < CAREFUL of max then alert = OK
# If current > CAREFUL of max then alert = CAREFUL
# If current > WARNING of max then alert = WARNING
# If current > CRITICAL of max then alert = CRITICAL
#
# If defined 'header' is added between the plugin name and the status
# Only usefull for stats with several alert status
#
# If log=True than return the logged status
# Compute the %
try:
value = (current * 100) / max
except ZeroDivisionError:
return 'DEFAULT'
except TypeError:
return 'DEFAULT'
# Manage limits
ret = 'OK'
if value > self.__get_limit_critical(header=header):
ret = 'CRITICAL'
elif value > self.__get_limit_warning(header=header):
ret = 'WARNING'
elif value > self.__get_limit_careful(header=header):
ret = 'CAREFUL'
elif current < min:
ret = 'CAREFUL'
# Manage log (if needed)
log_str = ""
if log:
# Add _LOG to the return string
# So stats will be highlited with a specific color
log_str = "_LOG"
# Get the stat_name = plugin_name (+ header)
if header == "":
stat_name = self.plugin_name
else:
stat_name = self.plugin_name + '_' + header
# Add the log to the list
glances_logs.add(ret, stat_name.upper(), value, [])
# Default is ok
return ret + log_str
def get_alert_log(self, current=0, min=0, max=100, header=""):
return self.get_alert(current, min, max, header, log=True)
def __get_limit_critical(self, header=""):
if header == "":
return self.limits[self.plugin_name + '_' + 'critical']
else:
return self.limits[self.plugin_name + '_' + header + '_' + 'critical']
def __get_limit_warning(self, header=""):
if header == "":
return self.limits[self.plugin_name + '_' + 'warning']
else:
return self.limits[self.plugin_name + '_' + header + '_' + 'warning']
def __get_limit_careful(self, header=""):
if header == "":
return self.limits[self.plugin_name + '_' + 'careful']
else:
return self.limits[self.plugin_name + '_' + header + '_' + 'careful']
def get_hide(self, header=""):
"""
Return the hide configuration list key for the current plugin
"""
if header == "":
try:
return self.limits[self.plugin_name + '_' + 'hide']
except KeyError:
return []
else:
try:
return self.limits[self.plugin_name + '_' + header + '_' + 'hide']
except KeyError:
return []
def is_hide(self, value, header=""):
"""
Return True if the value is in the hide configuration list
"""
return value in self.get_hide(header=header)
def msg_curse(self, args):
"""
Return default string to display in the curse interface
"""
return [self.curse_add_line(str(self.stats))]
def get_stats_display(self, args=None):
# Return a dict with all the information needed to display the stat
# key | description
#----------------------------
# display | Display the stat (True or False)
# msgdict | Message to display (list of dict [{ 'msg': msg, 'decoration': decoration } ... ])
# column | column number
# line | Line number
display_curse = False
column_curse = -1
line_curse = -1
if hasattr(self, 'display_curse'):
display_curse = self.display_curse
if hasattr(self, 'column_curse'):
column_curse = self.column_curse
if hasattr(self, 'line_curse'):
line_curse = self.line_curse
return {'display': display_curse,
'msgdict': self.msg_curse(args),
'column': column_curse,
'line': line_curse}
def curse_add_line(self, msg, decoration="DEFAULT", optional=False, splittable=False):
"""
Return a dict with: { 'msg': msg, 'decoration': decoration, 'optional': False }
with:
msg: string
decoration:
DEFAULT: no decoration
UNDERLINE: underline
BOLD: bold
TITLE: for stat title
PROCESS: for process name
STATUS: for process status
NICE: for process niceness
OK: Value is OK and non logged
OK_LOG: Value is OK and logged
CAREFUL: Value is CAREFUL and non logged
CAREFUL_LOG: Value is CAREFUL and logged
WARNING: Value is WARINING and non logged
WARNING_LOG: Value is WARINING and logged
CRITICAL: Value is CRITICAL and non logged
CRITICAL_LOG: Value is CRITICAL and logged
optional: True if the stat is optional (display only if space is available)
spittable: Line can be splitted to fit on the screen (default is not)
"""
return {'msg': msg, 'decoration': decoration, 'optional': optional, 'splittable': splittable}
def curse_new_line(self):
"""
Go to a new line
"""
return self.curse_add_line('\n')
def auto_unit(self, val, low_precision=False):
"""
Make a nice human readable string out of val
Number of decimal places increases as quantity approaches 1
|