glances.plugins.smart.convert_attribute_to_dict() - Code Metrics - Inspection of "NVME support" - nicolargo/glances - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — develop (#3355)

unknown

created 2025-12-22 07:30 UTC

glances.plugins.smart.convert_attribute_to_dict() A

↳ Parent: glances.plugins.smart

Complexity

Conditions

Size

Total Lines	12
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	12
nop	1
dl	0
loc	12
rs	9.8
c	0
b	0
f	0

#
# This file is part of Glances.
#
# Copyright (C) 2018 Tim Nibert <[email protected]>
#
# SPDX-License-Identifier: LGPL-3.0-only
#

"""
Hard disk SMART attributes plugin.
Depends on pySMART and smartmontools
Must execute as root
"usermod -a -G disk USERNAME" is not sufficient unfortunately
SmartCTL (/usr/sbin/smartctl) must be in system path for python2.

Regular PySMART is a python2 library.
We are using the pySMART.smartx updated library to support both python 2 and 3.

If we only have disk group access (no root):
$ smartctl -i /dev/sda
smartctl 6.6 2016-05-31 r4324 [x86_64-linux-4.15.0-30-generic] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org


Probable ATA device behind a SAT layer
Try an additional '-d ata' or '-d sat' argument.

This is not very hopeful: https://medium.com/opsops/why-smartctl-could-not-be-run-without-root-7ea0583b1323

So, here is what we are going to do:
Check for admin access.  If no admin access, disable SMART plugin.

If smartmontools is not installed, we should catch the error upstream in plugin initialization.
"""

from glances.globals import is_admin
from glances.logger import logger
from glances.main import disable
from glances.plugins.plugin.model import GlancesPluginModel

# Import plugin specific dependency
try:
    from pySMART import DeviceList
    from pySMART.interface.nvme import NvmeAttributes
except ImportError as e:
    import_error_tag = True
    logger.warning(f"Missing Python Lib ({e}), HDD Smart plugin is disabled")
else:
    import_error_tag = False


def convert_attribute_to_dict(attr):
    return {
        'name': attr.name,
        'num': attr.num,
        'flags': attr.flags,
        'raw': attr.raw,
        'value': attr.value,
        'worst': attr.worst,
        'threshold': attr.thresh,
        'type': attr.type,
        'updated': attr.updated,
        'when_failed': attr.when_failed,
    }

def convert_nvme_attribute_to_dict(key,value):
    return {
        'name': key,
        'value': value,
        'flags': None,
        'raw': value,
        'worst': None,
        'threshold': None,
        'type': None,
        'updated': None,
        'when_failed': None
    }

def get_smart_data():
    """
    Get SMART attribute data
    :return: list of multi leveled dictionaries
             each dict has a key "DeviceName" with the identification of the device in smartctl
             also has keys of the SMART attribute id, with value of another dict of the attributes
             [
                {
                    "DeviceName": "/dev/sda blahblah",
                    "1":
                    {
                        "flags": "..",
                        "raw": "..",
                        etc,
                    }
                    ...
                }
             ]
    """
    stats = []
    # get all devices
    try:
        devlist = DeviceList()
    except TypeError as e:
        # Catch error  (see #1806)
        logger.debug(f'Smart plugin error - Can not grab device list ({e})')
        global import_error_tag
        import_error_tag = True
        return stats

    for dev in devlist.devices:
        stats.append(
            {
                'DeviceName': f'{dev.name} {dev.model}',
            }
        )
        for attribute in dev.attributes:
            if attribute is None:
                pass
            else:
                attrib_dict = convert_attribute_to_dict(attribute)

                # we will use the attribute number as the key
                num = attrib_dict.pop('num', None)
                try:
                    assert num is not None
                except Exception as e:
                    # we should never get here, but if we do, continue to next iteration and skip this attribute
                    logger.debug(f'Smart plugin error - Skip the attribute {attribute} ({e})')
                    continue

                stats[-1][num] = attrib_dict

        if isinstance(dev.if_attributes, NvmeAttributes):
            idx = 0
            for attr in dev.if_attributes.__dict__.keys():
                idx +=1
                attrib_dict = convert_nvme_attribute_to_dict(attr,  dev.if_attributes.__dict__[attr])
                try:
                    if dev.if_attributes.__dict__[attr] is not None:
                        serialized = str(dev.if_attributes.__dict__[attr])
                except Exception as e:
                    logger.debug(f'Unable to serialize attribute {attr} from NVME')
                    attrib_dict['value'] = None
                    attrib_dict['raw'] = None
                finally:
                    stats[-1][idx] = attrib_dict

    return stats


class SmartPlugin(GlancesPluginModel):
    """Glances' HDD SMART plugin."""

    def __init__(self, args=None, config=None, stats_init_value=[]):
        """Init the plugin."""
        # check if user is admin
        if not is_admin() and args:
            disable(args, "smart")
            logger.debug("Current user is not admin, HDD SMART plugin disabled.")

        super().__init__(args=args, config=config)

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

    @GlancesPluginModel._check_decorator
    @GlancesPluginModel._log_result_decorator
    def update(self):
        """Update SMART stats using the input method."""
        # Init new stats
        stats = self.get_init_value()

        if import_error_tag:
            return self.stats

        if self.input_method == 'local':
            # Update stats and hide some sensors(#2996)
            stats = [s for s in get_smart_data() if self.is_display(s[self.get_key()])]
        elif self.input_method == 'snmp':
            pass

        # Update the stats
        self.stats = stats

        return self.stats

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

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

        # Only process if stats exist...
        if import_error_tag or not self.stats or self.is_disabled():
            return ret

        # Max size for the interface name
        if max_width:
            name_max_width = max_width - 6
        else:
            # No max_width defined, return an empty curse message
            logger.debug(f"No max_width defined for the {self.plugin_name} plugin, it will not be displayed.")
            return ret

        # Header
        msg = '{:{width}}'.format('SMART disks', width=name_max_width)
        ret.append(self.curse_add_line(msg, "TITLE"))
        # Data
        for device_stat in self.stats:
            # New line
            ret.append(self.curse_new_line())
            msg = '{:{width}}'.format(device_stat['DeviceName'][:max_width], width=max_width)
            ret.append(self.curse_add_line(msg))
            try:
                device_stat_sorted = sorted([i for i in device_stat if i != 'DeviceName'], key=int)
            except ValueError:
                # Catch ValueError, see #2904
                device_stat_sorted = [i for i in device_stat if i != 'DeviceName']
            for smart_stat in device_stat_sorted:
                ret.append(self.curse_new_line())
                msg = ' {:{width}}'.format(
                    device_stat[smart_stat]['name'][: name_max_width - 1].replace('_', ' '), width=name_max_width - 1
                )
                ret.append(self.curse_add_line(msg))
                try:
                    raw = device_stat[smart_stat]['raw']
                    msg = '{:>8}'.format("" if raw is None else str(raw))
                    ret.append(self.curse_add_line(msg))
                except Exception as e:
                    logger.debug(f"Failed to serialize {smart_stat}")
                    meg = ""
                    ret.append(self.curse_add_line(msg))

        return ret


1			#
2			# This file is part of Glances.
3			#
4			# Copyright (C) 2018 Tim Nibert <[email protected]>
5			#
6			# SPDX-License-Identifier: LGPL-3.0-only
7			#
8
9			"""
10			Hard disk SMART attributes plugin.
11			Depends on pySMART and smartmontools
12			Must execute as root
13			"usermod -a -G disk USERNAME" is not sufficient unfortunately
14			SmartCTL (/usr/sbin/smartctl) must be in system path for python2.
15
16			Regular PySMART is a python2 library.
17			We are using the pySMART.smartx updated library to support both python 2 and 3.
18
19			If we only have disk group access (no root):
20			$ smartctl -i /dev/sda
21			smartctl 6.6 2016-05-31 r4324 [x86_64-linux-4.15.0-30-generic] (local build)
22			Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org
23
24
25			Probable ATA device behind a SAT layer
26			Try an additional '-d ata' or '-d sat' argument.
27
28			This is not very hopeful: https://medium.com/opsops/why-smartctl-could-not-be-run-without-root-7ea0583b1323
29
30			So, here is what we are going to do:
31			Check for admin access. If no admin access, disable SMART plugin.
32
33			If smartmontools is not installed, we should catch the error upstream in plugin initialization.
34			"""
35
36			from glances.globals import is_admin
37			from glances.logger import logger
38			from glances.main import disable
39			from glances.plugins.plugin.model import GlancesPluginModel
40
41			# Import plugin specific dependency
42			try:
43			from pySMART import DeviceList
44			from pySMART.interface.nvme import NvmeAttributes
45			except ImportError as e:
46			import_error_tag = True
47			logger.warning(f"Missing Python Lib ({e}), HDD Smart plugin is disabled")
48			else:
49			import_error_tag = False
50
51
52			def convert_attribute_to_dict(attr):
53			return {
54			'name': attr.name,
55			'num': attr.num,
56			'flags': attr.flags,
57			'raw': attr.raw,
58			'value': attr.value,
59			'worst': attr.worst,
60			'threshold': attr.thresh,
61			'type': attr.type,
62			'updated': attr.updated,
63			'when_failed': attr.when_failed,
64			}
65
66			def convert_nvme_attribute_to_dict(key,value):
67			return {
68			'name': key,
69			'value': value,
70			'flags': None,
71			'raw': value,
72			'worst': None,
73			'threshold': None,
74			'type': None,
75			'updated': None,
76			'when_failed': None
77			}
78
79			def get_smart_data():
80			"""
81			Get SMART attribute data
82			:return: list of multi leveled dictionaries
83			each dict has a key "DeviceName" with the identification of the device in smartctl
84			also has keys of the SMART attribute id, with value of another dict of the attributes
85			[
86			{
87			"DeviceName": "/dev/sda blahblah",
88			"1":
89			{
90			"flags": "..",
91			"raw": "..",
92			etc,
93			}
94			...
95			}
96			]
97			"""
98			stats = []
99			# get all devices
100			try:
101			devlist = DeviceList()
102			except TypeError as e:
103			# Catch error (see #1806)
104			logger.debug(f'Smart plugin error - Can not grab device list ({e})')
105			global import_error_tag
106			import_error_tag = True
107			return stats
108
109			for dev in devlist.devices:
110			stats.append(
111			{
112			'DeviceName': f'{dev.name} {dev.model}',
113			}
114			)
115			for attribute in dev.attributes:
116			if attribute is None:
117			pass
118			else:
119			attrib_dict = convert_attribute_to_dict(attribute)
120
121			# we will use the attribute number as the key
122			num = attrib_dict.pop('num', None)
123			try:
124			assert num is not None
125			except Exception as e:
126			# we should never get here, but if we do, continue to next iteration and skip this attribute
127			logger.debug(f'Smart plugin error - Skip the attribute {attribute} ({e})')
128			continue
129
130			stats[-1][num] = attrib_dict
131
132			if isinstance(dev.if_attributes, NvmeAttributes):
133			idx = 0
134			for attr in dev.if_attributes.__dict__.keys():
135			idx +=1
136			attrib_dict = convert_nvme_attribute_to_dict(attr, dev.if_attributes.__dict__[attr])
137			try:
138			if dev.if_attributes.__dict__[attr] is not None:
139			serialized = str(dev.if_attributes.__dict__[attr])
140			except Exception as e:
141			logger.debug(f'Unable to serialize attribute {attr} from NVME')
142			attrib_dict['value'] = None
143			attrib_dict['raw'] = None
144			finally:
145			stats[-1][idx] = attrib_dict
146
147			return stats
148
149
150			class SmartPlugin(GlancesPluginModel):
151			"""Glances' HDD SMART plugin."""
152
153			def __init__(self, args=None, config=None, stats_init_value=[]):
154			"""Init the plugin."""
155			# check if user is admin
156			if not is_admin() and args:
157			disable(args, "smart")
158			logger.debug("Current user is not admin, HDD SMART plugin disabled.")
159
160			super().__init__(args=args, config=config)
161
162			# We want to display the stat in the curse interface
163			self.display_curse = True
164
165			@GlancesPluginModel._check_decorator
166			@GlancesPluginModel._log_result_decorator
167			def update(self):
168			"""Update SMART stats using the input method."""
169			# Init new stats
170			stats = self.get_init_value()
171
172			if import_error_tag:
173			return self.stats
174
175			if self.input_method == 'local':
176			# Update stats and hide some sensors(#2996)
177			stats = [s for s in get_smart_data() if self.is_display(s[self.get_key()])]
178			elif self.input_method == 'snmp':
179			pass
180
181			# Update the stats
182			self.stats = stats
183
184			return self.stats
185
186			def get_key(self):
187			"""Return the key of the list."""
188			return 'DeviceName'
189
190			def msg_curse(self, args=None, max_width=None):
191			"""Return the dict to display in the curse interface."""
192			# Init the return message
193			ret = []
194
195			# Only process if stats exist...
196			if import_error_tag or not self.stats or self.is_disabled():
197			return ret
198
199			# Max size for the interface name
200			if max_width:
201			name_max_width = max_width - 6
202			else:
203			# No max_width defined, return an empty curse message
204			logger.debug(f"No max_width defined for the {self.plugin_name} plugin, it will not be displayed.")
205			return ret
206
207			# Header
208			msg = '{:{width}}'.format('SMART disks', width=name_max_width)
209			ret.append(self.curse_add_line(msg, "TITLE"))
210			# Data
211			for device_stat in self.stats:
212			# New line
213			ret.append(self.curse_new_line())
214			msg = '{:{width}}'.format(device_stat['DeviceName'][:max_width], width=max_width)
215			ret.append(self.curse_add_line(msg))
216			try:
217			device_stat_sorted = sorted([i for i in device_stat if i != 'DeviceName'], key=int)
218			except ValueError:
219			# Catch ValueError, see #2904
220			device_stat_sorted = [i for i in device_stat if i != 'DeviceName']
221			for smart_stat in device_stat_sorted:
222			ret.append(self.curse_new_line())
223			msg = ' {:{width}}'.format(
224			device_stat[smart_stat]['name'][: name_max_width - 1].replace('_', ' '), width=name_max_width - 1
225			)
226			ret.append(self.curse_add_line(msg))
227			try:
228			raw = device_stat[smart_stat]['raw']
229			msg = '{:>8}'.format("" if raw is None else str(raw))
230			ret.append(self.curse_add_line(msg))
231			except Exception as e:
232			logger.debug(f"Failed to serialize {smart_stat}")
233			meg = ""
234			ret.append(self.curse_add_line(msg))
235
236			return ret
237

nicolargo / glances

Pull Request — develop (#3355)

glances.plugins.smart.convert_attribute_to_dict() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like