GlancesGrabSensors.build_sensors_list() - Code Metrics - Inspection of "Glances 2.9" - nicolargo/glances - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a1acfe...a11662 )

by Nicolas

created 2017-03-27 15:19 UTC

GlancesGrabSensors.build_sensors_list() D

↳ Parent: GlancesGrabSensors

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	8
c	1
b	0
f	0
dl	0
loc	31
rs	4

# -*- coding: utf-8 -*-
#
# This file is part of Glances.
#
# Copyright (C) 2017 Nicolargo <[email protected]>
#
# 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/>.

"""Sensors plugin."""

import psutil

from glances.logger import logger
from glances.compat import iteritems
from glances.plugins.glances_batpercent import Plugin as BatPercentPlugin
from glances.plugins.glances_hddtemp import Plugin as HddTempPlugin
from glances.plugins.glances_plugin import GlancesPlugin

SENSOR_TEMP_UNIT = 'C'
SENSOR_FAN_UNIT = 'rpm'


def to_fahrenheit(celsius):
    """Convert Celsius to Fahrenheit."""
    return celsius * 1.8 + 32


class Plugin(GlancesPlugin):

    """Glances sensors plugin.

    The stats list includes both sensors and hard disks stats, if any.
    The sensors are already grouped by chip type and then sorted by name.
    The hard disks are already sorted by name.
    """

    def __init__(self, args=None):
        """Init the plugin."""
        super(Plugin, self).__init__(args=args)

        # Init the sensor class
        self.glancesgrabsensors = GlancesGrabSensors()

        # Instance for the HDDTemp Plugin in order to display the hard disks
        # temperatures
        self.hddtemp_plugin = HddTempPlugin(args=args)

        # Instance for the BatPercent in order to display the batteries
        # capacities
        self.batpercent_plugin = BatPercentPlugin(args=args)

        # We want to display the stat in the curse interface
        self.display_curse = True

        # Init the stats
        self.reset()

    def get_key(self):
        """Return the key of the list."""
        return 'label'

    def reset(self):
        """Reset/init the stats."""
        self.stats = []

    @GlancesPlugin._check_decorator
    @GlancesPlugin._log_result_decorator
    def update(self):
        """Update sensors stats using the input method."""
        # Reset the stats
        self.reset()

        if self.input_method == 'local':
            # Update stats using the dedicated lib
            self.stats = []
            # Get the temperature
            try:
                temperature = self.__set_type(self.glancesgrabsensors.get('temperature_core'),
                                              'temperature_core')
            except Exception as e:
                logger.error("Cannot grab sensors temperatures (%s)" % e)
            else:
                # Append temperature
                self.stats.extend(temperature)
            # Get the FAN speed
            try:
                fan_speed = self.__set_type(self.glancesgrabsensors.get('fan_speed'),
                                            'fan_speed')
            except Exception as e:
                logger.error("Cannot grab FAN speed (%s)" % e)
            else:
                # Append FAN speed
                self.stats.extend(fan_speed)
            # Update HDDtemp stats
            try:
                hddtemp = self.__set_type(self.hddtemp_plugin.update(),
                                          'temperature_hdd')
            except Exception as e:
                logger.error("Cannot grab HDD temperature (%s)" % e)
            else:
                # Append HDD temperature
                self.stats.extend(hddtemp)
            # Update batteries stats
            try:
                batpercent = self.__set_type(self.batpercent_plugin.update(),
                                             'battery')
            except Exception as e:
                logger.error("Cannot grab battery percent (%s)" % e)
            else:
                # Append Batteries %
                self.stats.extend(batpercent)

        elif self.input_method == 'snmp':
            # Update stats using SNMP
            # No standard:
            # http://www.net-snmp.org/wiki/index.php/Net-SNMP_and_lm-sensors_on_Ubuntu_10.04

            pass

        return self.stats

    def __set_type(self, stats, sensor_type):
        """Set the plugin type.

        4 types of stats is possible in the sensors plugin:
        - Core temperature: 'temperature_core'
        - Fan speed: 'fan_speed'
        - HDD temperature: 'temperature_hdd'
        - Battery capacity: 'battery'
        """
        for i in stats:
            # Set the sensors type
            i.update({'type': sensor_type})
            # also add the key name
            i.update({'key': self.get_key()})

        return stats

    def update_views(self):
        """Update stats views."""
        # Call the father's method
        super(Plugin, self).update_views()

        # Add specifics informations
        # Alert

        for i in self.stats:
            if not i['value']:
                continue
            if i['type'] == 'battery':
                self.views[i[self.get_key()]]['value']['decoration'] = self.get_alert(100 - i['value'], header=i['type'])
            else:
                self.views[i[self.get_key()]]['value']['decoration'] = self.get_alert(i['value'], header=i['type'])

    def msg_curse(self, args=None):
        """Return the dict to display in the curse interface."""
        # Init the return message
        ret = []

        # Only process if stats exist and display plugin enable...
        if not self.stats or args.disable_sensors:
            return ret

        # Build the string message
        # Header
        msg = '{:18}'.format('SENSORS')
        ret.append(self.curse_add_line(msg, "TITLE"))

        for i in self.stats:
            # Do not display anything if no battery are detected
            if i['type'] == 'battery' and i['value'] == []:
                continue
            # New line
            ret.append(self.curse_new_line())
            # Alias for the lable name ?
            label = self.has_alias(i['label'].lower())
            if label is None:
                label = i['label']
            if i['type'] != 'fan_speed':
                msg = '{:15}'.format(label[:15])
            else:
                msg = '{:13}'.format(label[:13])
            ret.append(self.curse_add_line(msg))
            if i['value'] in (b'ERR', b'SLP', b'UNK', b'NOS'):
                msg = '{:>8}'.format(i['value'])
                ret.append(self.curse_add_line(
                    msg, self.get_views(item=i[self.get_key()],
                                        key='value',
                                        option='decoration')))
            else:
                if (args.fahrenheit and i['type'] != 'battery' and
                        i['type'] != 'fan_speed'):
                    value = to_fahrenheit(i['value'])
                    unit = 'F'
                else:
                    value = i['value']
                    unit = i['unit']
                try:
                    msg = '{:>7.0f}{}'.format(value, unit)
                    ret.append(self.curse_add_line(
                        msg, self.get_views(item=i[self.get_key()],
                                            key='value',
                                            option='decoration')))
                except (TypeError, ValueError):
                    pass

        return ret


class GlancesGrabSensors(object):

    """Get sensors stats."""

    def __init__(self):
        """Init sensors stats."""
        # Temperatures
        self.init_temp = False
        self.stemps = {}
        try:
            # psutil>=5.1.0 is required
            self.stemps = psutil.sensors_temperatures()
        except AttributeError:
            logger.warning("PsUtil 5.1.0 or higher is needed to grab temperatures sensors")
        except OSError as e:
            # FreeBSD: If oid 'hw.acpi.battery' not present, Glances wont start #1055
            logger.error("Can not grab temperatures sensors ({})".format(e))
        else:
            self.init_temp = True

        # Fans
        self.init_fan = False
        self.sfans = {}
        try:
            # psutil>=5.2.0 is required
            self.sfans = psutil.sensors_fans()
        except AttributeError:
            logger.warning("PsUtil 5.2.0 or higher is needed to grab fans sensors")
        except OSError as e:
            logger.error("Can not grab fans sensors ({})".format(e))
        else:
            self.init_fan = True

        # !!! Disable Fan: High CPU consumption is PSUtil 5.2.0
        # Delete the following line when corrected
        self.init_fan = False

        # Init the stats
        self.reset()

    def reset(self):
        """Reset/init the stats."""
        self.sensors_list = []

    def __update__(self):
        """Update the stats."""
        # Reset the list
        self.reset()

        if not self.init_temp:
            return self.sensors_list

        # Temperatures sensors
        self.sensors_list.extend(self.build_sensors_list(SENSOR_TEMP_UNIT))

        # Fans sensors
        self.sensors_list.extend(self.build_sensors_list(SENSOR_FAN_UNIT))

        return self.sensors_list

    def build_sensors_list(self, type):
        """Build the sensors list depending of the type.

        type: SENSOR_TEMP_UNIT or SENSOR_FAN_UNIT

        output: a list"""
        ret = []
        if type == SENSOR_TEMP_UNIT and self.init_temp:
            input_list = self.stemps
            self.stemps = psutil.sensors_temperatures()
        elif type == SENSOR_FAN_UNIT and self.init_fan:
            input_list = self.sfans
            self.sfans = psutil.sensors_fans()
        else:
            return ret
        for chipname, chip in iteritems(input_list):
            i = 1
            for feature in chip:
                sensors_current = {}
                # Sensor name
                if feature.label == '':
                    sensors_current['label'] = chipname + ' ' + str(i)
                else:
                    sensors_current['label'] = feature.label
                # Fan speed and unit
                sensors_current['value'] = int(feature.current)
                sensors_current['unit'] = type
                # Add sensor to the list
                ret.append(sensors_current)
                i += 1
        return ret

    def get(self, sensor_type='temperature_core'):
        """Get sensors list."""
        self.__update__()
        if sensor_type == 'temperature_core':
            ret = [s for s in self.sensors_list if s['unit'] == SENSOR_TEMP_UNIT]
        elif sensor_type == 'fan_speed':
            ret = [s for s in self.sensors_list if s['unit'] == SENSOR_FAN_UNIT]
        else:
            # Unknown type
            logger.debug("Unknown sensor type %s" % sensor_type)
            ret = []
        return ret


1		# -- coding: utf-8 --
2		#
3		# This file is part of Glances.
4		#
5		# Copyright (C) 2017 Nicolargo <[email protected]>
6		#
7		# Glances is free software; you can redistribute it and/or modify
8		# it under the terms of the GNU Lesser General Public License as published by
9		# the Free Software Foundation, either version 3 of the License, or
10		# (at your option) any later version.
11		#
12		# Glances is distributed in the hope that it will be useful,
13		# but WITHOUT ANY WARRANTY; without even the implied warranty of
14		# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15		# GNU Lesser General Public License for more details.
16		#
17		# You should have received a copy of the GNU Lesser General Public License
18		# along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20		"""Sensors plugin."""
21
22		import psutil
23
24		from glances.logger import logger
25		from glances.compat import iteritems
26		from glances.plugins.glances_batpercent import Plugin as BatPercentPlugin
27		from glances.plugins.glances_hddtemp import Plugin as HddTempPlugin
28		from glances.plugins.glances_plugin import GlancesPlugin
29
30		SENSOR_TEMP_UNIT = 'C'
31		SENSOR_FAN_UNIT = 'rpm'
32
33
34		def to_fahrenheit(celsius):
35		"""Convert Celsius to Fahrenheit."""
36		return celsius * 1.8 + 32
37
38
39		class Plugin(GlancesPlugin):
40
41		"""Glances sensors plugin.
42
43		The stats list includes both sensors and hard disks stats, if any.
44		The sensors are already grouped by chip type and then sorted by name.
45		The hard disks are already sorted by name.
46		"""
47
48		def __init__(self, args=None):
49		"""Init the plugin."""
50		super(Plugin, self).__init__(args=args)
51
52		# Init the sensor class
53		self.glancesgrabsensors = GlancesGrabSensors()
54
55		# Instance for the HDDTemp Plugin in order to display the hard disks
56		# temperatures
57		self.hddtemp_plugin = HddTempPlugin(args=args)
58
59		# Instance for the BatPercent in order to display the batteries
60		# capacities
61		self.batpercent_plugin = BatPercentPlugin(args=args)
62
63		# We want to display the stat in the curse interface
64		self.display_curse = True
65
66		# Init the stats
67		self.reset()
68
69		def get_key(self):
70		"""Return the key of the list."""
71		return 'label'
72
73		def reset(self):
74		"""Reset/init the stats."""
75		self.stats = []
76
77		@GlancesPlugin._check_decorator
78		@GlancesPlugin._log_result_decorator
79		def update(self):
80		"""Update sensors stats using the input method."""
81		# Reset the stats
82		self.reset()
83
84		if self.input_method == 'local':
85		# Update stats using the dedicated lib
86		self.stats = []
87		# Get the temperature
88		try:
89		temperature = self.__set_type(self.glancesgrabsensors.get('temperature_core'),
90		'temperature_core')
91		except Exception as e:
92		logger.error("Cannot grab sensors temperatures (%s)" % e)
93		else:
94		# Append temperature
95		self.stats.extend(temperature)
96		# Get the FAN speed
97		try:
98		fan_speed = self.__set_type(self.glancesgrabsensors.get('fan_speed'),
99		'fan_speed')
100		except Exception as e:
101		logger.error("Cannot grab FAN speed (%s)" % e)
102		else:
103		# Append FAN speed
104		self.stats.extend(fan_speed)
105		# Update HDDtemp stats
106		try:
107		hddtemp = self.__set_type(self.hddtemp_plugin.update(),
108		'temperature_hdd')
109		except Exception as e:
110		logger.error("Cannot grab HDD temperature (%s)" % e)
111		else:
112		# Append HDD temperature
113		self.stats.extend(hddtemp)
114		# Update batteries stats
115		try:
116		batpercent = self.__set_type(self.batpercent_plugin.update(),
117		'battery')
118		except Exception as e:
119		logger.error("Cannot grab battery percent (%s)" % e)
120		else:
121		# Append Batteries %
122		self.stats.extend(batpercent)
123
124		elif self.input_method == 'snmp':
125		# Update stats using SNMP
126		# No standard:
127		# http://www.net-snmp.org/wiki/index.php/Net-SNMP_and_lm-sensors_on_Ubuntu_10.04
128
129		pass
130
131		return self.stats
132
133		def __set_type(self, stats, sensor_type):
134		"""Set the plugin type.
135
136		4 types of stats is possible in the sensors plugin:
137		- Core temperature: 'temperature_core'
138		- Fan speed: 'fan_speed'
139		- HDD temperature: 'temperature_hdd'
140		- Battery capacity: 'battery'
141		"""
142		for i in stats:
143		# Set the sensors type
144		i.update({'type': sensor_type})
145		# also add the key name
146		i.update({'key': self.get_key()})
147
148		return stats
149
150		def update_views(self):
151		"""Update stats views."""
152		# Call the father's method
153		super(Plugin, self).update_views()
154
155		# Add specifics informations
156	View Code Duplication	# Alert
		0 ignored issues – show Duplication introduced 2016-04-28 14:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
157		for i in self.stats:
158		if not i['value']:
159		continue
160		if i['type'] == 'battery':
161		self.views[i[self.get_key()]]['value']['decoration'] = self.get_alert(100 - i['value'], header=i['type'])
162		else:
163		self.views[i[self.get_key()]]['value']['decoration'] = self.get_alert(i['value'], header=i['type'])
164
165		def msg_curse(self, args=None):
166		"""Return the dict to display in the curse interface."""
167		# Init the return message
168		ret = []
169
170		# Only process if stats exist and display plugin enable...
171		if not self.stats or args.disable_sensors:
172		return ret
173
174		# Build the string message
175		# Header
176		msg = '{:18}'.format('SENSORS')
177		ret.append(self.curse_add_line(msg, "TITLE"))
178
179		for i in self.stats:
180		# Do not display anything if no battery are detected
181		if i['type'] == 'battery' and i['value'] == []:
182		continue
183		# New line
184		ret.append(self.curse_new_line())
185		# Alias for the lable name ?
186		label = self.has_alias(i['label'].lower())
187		if label is None:
188		label = i['label']
189		if i['type'] != 'fan_speed':
190		msg = '{:15}'.format(label[:15])
191		else:
192		msg = '{:13}'.format(label[:13])
193		ret.append(self.curse_add_line(msg))
194		if i['value'] in (b'ERR', b'SLP', b'UNK', b'NOS'):
195		msg = '{:>8}'.format(i['value'])
196		ret.append(self.curse_add_line(
197		msg, self.get_views(item=i[self.get_key()],
198		key='value',
199		option='decoration')))
200		else:
201		if (args.fahrenheit and i['type'] != 'battery' and
202		i['type'] != 'fan_speed'):
203		value = to_fahrenheit(i['value'])
204		unit = 'F'
205		else:
206		value = i['value']
207		unit = i['unit']
208		try:
209		msg = '{:>7.0f}{}'.format(value, unit)
210		ret.append(self.curse_add_line(
211		msg, self.get_views(item=i[self.get_key()],
212		key='value',
213		option='decoration')))
214		except (TypeError, ValueError):
215		pass
216
217		return ret
218
219
220		class GlancesGrabSensors(object):
221
222		"""Get sensors stats."""
223
224		def __init__(self):
225		"""Init sensors stats."""
226		# Temperatures
227		self.init_temp = False
228		self.stemps = {}
229		try:
230		# psutil>=5.1.0 is required
231		self.stemps = psutil.sensors_temperatures()
232		except AttributeError:
233		logger.warning("PsUtil 5.1.0 or higher is needed to grab temperatures sensors")
234		except OSError as e:
235		# FreeBSD: If oid 'hw.acpi.battery' not present, Glances wont start #1055
236		logger.error("Can not grab temperatures sensors ({})".format(e))
237		else:
238		self.init_temp = True
239
240		# Fans
241		self.init_fan = False
242		self.sfans = {}
243		try:
244		# psutil>=5.2.0 is required
245		self.sfans = psutil.sensors_fans()
246		except AttributeError:
247		logger.warning("PsUtil 5.2.0 or higher is needed to grab fans sensors")
248		except OSError as e:
249		logger.error("Can not grab fans sensors ({})".format(e))
250		else:
251		self.init_fan = True
252
253		# !!! Disable Fan: High CPU consumption is PSUtil 5.2.0
254		# Delete the following line when corrected
255		self.init_fan = False
256
257		# Init the stats
258		self.reset()
259
260		def reset(self):
261		"""Reset/init the stats."""
262		self.sensors_list = []
263
264		def __update__(self):
265		"""Update the stats."""
266		# Reset the list
267		self.reset()
268
269		if not self.init_temp:
270		return self.sensors_list
271
272		# Temperatures sensors
273		self.sensors_list.extend(self.build_sensors_list(SENSOR_TEMP_UNIT))
274
275		# Fans sensors
276		self.sensors_list.extend(self.build_sensors_list(SENSOR_FAN_UNIT))
277
278		return self.sensors_list
279
280		def build_sensors_list(self, type):
281		"""Build the sensors list depending of the type.
282
283		type: SENSOR_TEMP_UNIT or SENSOR_FAN_UNIT
284
285		output: a list"""
286		ret = []
287		if type == SENSOR_TEMP_UNIT and self.init_temp:
288		input_list = self.stemps
289		self.stemps = psutil.sensors_temperatures()
290		elif type == SENSOR_FAN_UNIT and self.init_fan:
291		input_list = self.sfans
292		self.sfans = psutil.sensors_fans()
293		else:
294		return ret
295		for chipname, chip in iteritems(input_list):
296		i = 1
297		for feature in chip:
298		sensors_current = {}
299		# Sensor name
300		if feature.label == '':
301		sensors_current['label'] = chipname + ' ' + str(i)
302		else:
303		sensors_current['label'] = feature.label
304		# Fan speed and unit
305		sensors_current['value'] = int(feature.current)
306		sensors_current['unit'] = type
307		# Add sensor to the list
308		ret.append(sensors_current)
309		i += 1
310		return ret
311
312		def get(self, sensor_type='temperature_core'):
313		"""Get sensors list."""
314		self.__update__()
315		if sensor_type == 'temperature_core':
316		ret = [s for s in self.sensors_list if s['unit'] == SENSOR_TEMP_UNIT]
317		elif sensor_type == 'fan_speed':
318		ret = [s for s in self.sensors_list if s['unit'] == SENSOR_FAN_UNIT]
319		else:
320		# Unknown type
321		logger.debug("Unknown sensor type %s" % sensor_type)
322		ret = []
323		return ret
324

nicolargo / glances

Push — master ( a1acfe...a11662 )

GlancesGrabSensors.build_sensors_list() D

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like