Config.read() - Code Metrics - Inspection of "version 2.8.1" - nicolargo/glances - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e61e99...a0b053 )

by Nicolas

created 2017-02-06 17:13 UTC

Config.read() F

↳ Parent: Config

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	15
dl	0
loc	85
rs	2
c	1
b	0
f	0

How to fix Long Method Complexity

# -*- 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/>.

"""Manage the configuration file."""

import os
import sys
import multiprocessing
from io import open

from glances.compat import ConfigParser, NoOptionError
from glances.globals import BSD, LINUX, MACOS, SUNOS, WINDOWS
from glances.logger import logger


def user_config_dir():
    r"""Return the per-user config dir (full path).

    - Linux, *BSD, SunOS: ~/.config/glances
    - macOS: ~/Library/Application Support/glances
    - Windows: %APPDATA%\glances
    """
    if WINDOWS:
        path = os.environ.get('APPDATA')
    elif MACOS:
        path = os.path.expanduser('~/Library/Application Support')
    else:
        path = os.environ.get('XDG_CONFIG_HOME') or os.path.expanduser('~/.config')
    path = os.path.join(path, 'glances')

    return path


def user_cache_dir():
    r"""Return the per-user cache dir (full path).

    - Linux, *BSD, SunOS: ~/.cache/glances
    - macOS: ~/Library/Caches/glances
    - Windows: %LOCALAPPDATA%\glances\cache
    """
    if WINDOWS:
        path = os.path.join(os.environ.get('LOCALAPPDATA'), 'glances', 'cache')
    elif MACOS:
        path = os.path.expanduser('~/Library/Caches/glances')
    else:
        path = os.path.join(os.environ.get('XDG_CACHE_HOME') or os.path.expanduser('~/.cache'),
                            'glances')

    return path


def system_config_dir():
    r"""Return the system-wide config dir (full path).

    - Linux, SunOS: /etc/glances
    - *BSD, macOS: /usr/local/etc/glances
    - Windows: %APPDATA%\glances
    """
    if LINUX or SUNOS:
        path = '/etc'
    elif BSD or MACOS:
        path = '/usr/local/etc'
    else:
        path = os.environ.get('APPDATA')
    path = os.path.join(path, 'glances')

    return path


class Config(object):

    """This class is used to access/read config file, if it exists.

    :param config_dir: the path to search for config file
    :type config_dir: str or None
    """

    def __init__(self, config_dir=None):
        self.config_dir = config_dir
        self.config_filename = 'glances.conf'
        self._loaded_config_file = None

        self.parser = ConfigParser()
        self.read()

    def config_file_paths(self):
        r"""Get a list of config file paths.

        The list is built taking into account of the OS, priority and location.

        * custom path: /path/to/glances
        * Linux, SunOS: ~/.config/glances, /etc/glances
        * *BSD: ~/.config/glances, /usr/local/etc/glances
        * macOS: ~/Library/Application Support/glances, /usr/local/etc/glances
        * Windows: %APPDATA%\glances

        The config file will be searched in the following order of priority:
            * /path/to/file (via -C flag)
            * user's home directory (per-user settings)
            * system-wide directory (system-wide settings)
        """
        paths = []

        if self.config_dir:
            paths.append(self.config_dir)

        paths.append(os.path.join(user_config_dir(), self.config_filename))
        paths.append(os.path.join(system_config_dir(), self.config_filename))

        return paths

    def read(self):
        """Read the config file, if it exists. Using defaults otherwise."""
        for config_file in self.config_file_paths():
            if os.path.exists(config_file):
                try:
                    with open(config_file, encoding='utf-8') as f:
                        self.parser.read_file(f)
                        self.parser.read(f)
                    logger.info("Read configuration file '{}'".format(config_file))
                except UnicodeDecodeError as err:
                    logger.error("Cannot decode configuration file '{}': {}".format(config_file, err))
                    sys.exit(1)
                # Save the loaded configuration file path (issue #374)
                self._loaded_config_file = config_file
                break

        # Quicklook
        if not self.parser.has_section('quicklook'):
            self.parser.add_section('quicklook')
        self.set_default_cwc('quicklook', 'cpu')
        self.set_default_cwc('quicklook', 'mem')
        self.set_default_cwc('quicklook', 'swap')

        # CPU
        if not self.parser.has_section('cpu'):
            self.parser.add_section('cpu')
        self.set_default_cwc('cpu', 'user')
        self.set_default_cwc('cpu', 'system')
        self.set_default_cwc('cpu', 'steal')
        # By default I/O wait should be lower than 1/number of CPU cores
        iowait_bottleneck = (1.0 / multiprocessing.cpu_count()) * 100.0
        self.set_default_cwc('cpu', 'iowait',
                             [str(iowait_bottleneck - (iowait_bottleneck * 0.20)),
                              str(iowait_bottleneck - (iowait_bottleneck * 0.10)),
                              str(iowait_bottleneck)])
        ctx_switches_bottleneck = 56000 / multiprocessing.cpu_count()
        self.set_default_cwc('cpu', 'ctx_switches',
                             [str(ctx_switches_bottleneck - (ctx_switches_bottleneck * 0.20)),
                              str(ctx_switches_bottleneck - (ctx_switches_bottleneck * 0.10)),
                              str(ctx_switches_bottleneck)])

        # Per-CPU
        if not self.parser.has_section('percpu'):
            self.parser.add_section('percpu')
        self.set_default_cwc('percpu', 'user')
        self.set_default_cwc('percpu', 'system')

        # Load
        if not self.parser.has_section('load'):
            self.parser.add_section('load')
        self.set_default_cwc('load', cwc=['0.7', '1.0', '5.0'])

        # Mem
        if not self.parser.has_section('mem'):
            self.parser.add_section('mem')
        self.set_default_cwc('mem')

        # Swap
        if not self.parser.has_section('memswap'):
            self.parser.add_section('memswap')
        self.set_default_cwc('memswap')

        # NETWORK
        if not self.parser.has_section('network'):
            self.parser.add_section('network')
        self.set_default_cwc('network', 'rx')
        self.set_default_cwc('network', 'tx')

        # FS
        if not self.parser.has_section('fs'):
            self.parser.add_section('fs')
        self.set_default_cwc('fs')

        # Sensors
        if not self.parser.has_section('sensors'):
            self.parser.add_section('sensors')
        self.set_default_cwc('sensors', 'temperature_core', cwc=['60', '70', '80'])
        self.set_default_cwc('sensors', 'temperature_hdd', cwc=['45', '52', '60'])
        self.set_default_cwc('sensors', 'battery', cwc=['80', '90', '95'])

        # Process list
        if not self.parser.has_section('processlist'):
            self.parser.add_section('processlist')
        self.set_default_cwc('processlist', 'cpu')
        self.set_default_cwc('processlist', 'mem')

    @property
    def loaded_config_file(self):
        """Return the loaded configuration file."""
        return self._loaded_config_file

    def as_dict(self):
        """Return the configuration as a dict"""
        dictionary = {}
        for section in self.parser.sections():
            dictionary[section] = {}
            for option in self.parser.options(section):
                dictionary[section][option] = self.parser.get(section, option)
        return dictionary

    def sections(self):
        """Return a list of all sections."""
        return self.parser.sections()

    def items(self, section):
        """Return the items list of a section."""
        return self.parser.items(section)

    def has_section(self, section):
        """Return info about the existence of a section."""
        return self.parser.has_section(section)

    def set_default_cwc(self, section,
                        option_header=None,
                        cwc=['50', '70', '90']):
        """Set default values for careful, warning and critical."""
        if option_header is None:
            header = ''
        else:
            header = option_header + '_'
        self.set_default(section, header + 'careful', cwc[0])
        self.set_default(section, header + 'warning', cwc[1])
        self.set_default(section, header + 'critical', cwc[2])

    def set_default(self, section, option, default):
        """If the option did not exist, create a default value."""
        if not self.parser.has_option(section, option):
            self.parser.set(section, option, default)

    def get_value(self, section, option, default=None):
        """Get the value of an option, if it exists."""
        try:
            return self.parser.get(section, option)
        except NoOptionError:
            return default

    def get_int_value(self, section, option, default=0):
        """Get the int value of an option, if it exists."""
        try:
            return self.parser.getint(section, option)
        except NoOptionError:
            return int(default)

    def get_float_value(self, section, option, default=0.0):
        """Get the float value of an option, if it exists."""
        try:
            return self.parser.getfloat(section, option)
        except NoOptionError:
            return float(default)


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			"""Manage the configuration file."""
21
22			import os
23			import sys
24			import multiprocessing
25			from io import open
26
27			from glances.compat import ConfigParser, NoOptionError
28			from glances.globals import BSD, LINUX, MACOS, SUNOS, WINDOWS
29			from glances.logger import logger
30
31
32			def user_config_dir():
33			r"""Return the per-user config dir (full path).
34
35			- Linux, *BSD, SunOS: ~/.config/glances
36			- macOS: ~/Library/Application Support/glances
37			- Windows: %APPDATA%\glances
38			"""
39			if WINDOWS:
40			path = os.environ.get('APPDATA')
41			elif MACOS:
42			path = os.path.expanduser('~/Library/Application Support')
43			else:
44			path = os.environ.get('XDG_CONFIG_HOME') or os.path.expanduser('~/.config')
45			path = os.path.join(path, 'glances')
46
47			return path
48
49
50			def user_cache_dir():
51			r"""Return the per-user cache dir (full path).
52
53			- Linux, *BSD, SunOS: ~/.cache/glances
54			- macOS: ~/Library/Caches/glances
55			- Windows: %LOCALAPPDATA%\glances\cache
56			"""
57			if WINDOWS:
58			path = os.path.join(os.environ.get('LOCALAPPDATA'), 'glances', 'cache')
59			elif MACOS:
60			path = os.path.expanduser('~/Library/Caches/glances')
61			else:
62			path = os.path.join(os.environ.get('XDG_CACHE_HOME') or os.path.expanduser('~/.cache'),
63			'glances')
64
65			return path
66
67
68			def system_config_dir():
69			r"""Return the system-wide config dir (full path).
70
71			- Linux, SunOS: /etc/glances
72			- *BSD, macOS: /usr/local/etc/glances
73			- Windows: %APPDATA%\glances
74			"""
75			if LINUX or SUNOS:
76			path = '/etc'
77			elif BSD or MACOS:
78			path = '/usr/local/etc'
79			else:
80			path = os.environ.get('APPDATA')
81			path = os.path.join(path, 'glances')
82
83			return path
84
85
86			class Config(object):
87
88			"""This class is used to access/read config file, if it exists.
89
90			:param config_dir: the path to search for config file
91			:type config_dir: str or None
92			"""
93
94			def __init__(self, config_dir=None):
95			self.config_dir = config_dir
96			self.config_filename = 'glances.conf'
97			self._loaded_config_file = None
98
99			self.parser = ConfigParser()
100			self.read()
101
102			def config_file_paths(self):
103			r"""Get a list of config file paths.
104
105			The list is built taking into account of the OS, priority and location.
106
107			* custom path: /path/to/glances
108			* Linux, SunOS: ~/.config/glances, /etc/glances
109			* *BSD: ~/.config/glances, /usr/local/etc/glances
110			* macOS: ~/Library/Application Support/glances, /usr/local/etc/glances
111			* Windows: %APPDATA%\glances
112
113			The config file will be searched in the following order of priority:
114			* /path/to/file (via -C flag)
115			* user's home directory (per-user settings)
116			* system-wide directory (system-wide settings)
117			"""
118			paths = []
119
120			if self.config_dir:
121			paths.append(self.config_dir)
122
123			paths.append(os.path.join(user_config_dir(), self.config_filename))
124			paths.append(os.path.join(system_config_dir(), self.config_filename))
125
126			return paths
127
128			def read(self):
129			"""Read the config file, if it exists. Using defaults otherwise."""
130			for config_file in self.config_file_paths():
131			if os.path.exists(config_file):
132			try:
133			with open(config_file, encoding='utf-8') as f:
134			self.parser.read_file(f)
135			self.parser.read(f)
136			logger.info("Read configuration file '{}'".format(config_file))
137			except UnicodeDecodeError as err:
138			logger.error("Cannot decode configuration file '{}': {}".format(config_file, err))
139			sys.exit(1)
140			# Save the loaded configuration file path (issue #374)
141			self._loaded_config_file = config_file
142			break
143
144			# Quicklook
145			if not self.parser.has_section('quicklook'):
146			self.parser.add_section('quicklook')
147			self.set_default_cwc('quicklook', 'cpu')
148			self.set_default_cwc('quicklook', 'mem')
149			self.set_default_cwc('quicklook', 'swap')
150
151			# CPU
152			if not self.parser.has_section('cpu'):
153			self.parser.add_section('cpu')
154			self.set_default_cwc('cpu', 'user')
155			self.set_default_cwc('cpu', 'system')
156			self.set_default_cwc('cpu', 'steal')
157			# By default I/O wait should be lower than 1/number of CPU cores
158			iowait_bottleneck = (1.0 / multiprocessing.cpu_count()) * 100.0
159			self.set_default_cwc('cpu', 'iowait',
160			[str(iowait_bottleneck - (iowait_bottleneck * 0.20)),
161			str(iowait_bottleneck - (iowait_bottleneck * 0.10)),
162			str(iowait_bottleneck)])
163			ctx_switches_bottleneck = 56000 / multiprocessing.cpu_count()
164			self.set_default_cwc('cpu', 'ctx_switches',
165			[str(ctx_switches_bottleneck - (ctx_switches_bottleneck * 0.20)),
166			str(ctx_switches_bottleneck - (ctx_switches_bottleneck * 0.10)),
167			str(ctx_switches_bottleneck)])
168
169			# Per-CPU
170			if not self.parser.has_section('percpu'):
171			self.parser.add_section('percpu')
172			self.set_default_cwc('percpu', 'user')
173			self.set_default_cwc('percpu', 'system')
174
175			# Load
176			if not self.parser.has_section('load'):
177			self.parser.add_section('load')
178			self.set_default_cwc('load', cwc=['0.7', '1.0', '5.0'])
179
180			# Mem
181			if not self.parser.has_section('mem'):
182			self.parser.add_section('mem')
183			self.set_default_cwc('mem')
184
185			# Swap
186			if not self.parser.has_section('memswap'):
187			self.parser.add_section('memswap')
188			self.set_default_cwc('memswap')
189
190			# NETWORK
191			if not self.parser.has_section('network'):
192			self.parser.add_section('network')
193			self.set_default_cwc('network', 'rx')
194			self.set_default_cwc('network', 'tx')
195
196			# FS
197			if not self.parser.has_section('fs'):
198			self.parser.add_section('fs')
199			self.set_default_cwc('fs')
200
201			# Sensors
202			if not self.parser.has_section('sensors'):
203			self.parser.add_section('sensors')
204			self.set_default_cwc('sensors', 'temperature_core', cwc=['60', '70', '80'])
205			self.set_default_cwc('sensors', 'temperature_hdd', cwc=['45', '52', '60'])
206			self.set_default_cwc('sensors', 'battery', cwc=['80', '90', '95'])
207
208			# Process list
209			if not self.parser.has_section('processlist'):
210			self.parser.add_section('processlist')
211			self.set_default_cwc('processlist', 'cpu')
212			self.set_default_cwc('processlist', 'mem')
213
214			@property
215			def loaded_config_file(self):
216			"""Return the loaded configuration file."""
217			return self._loaded_config_file
218
219			def as_dict(self):
220			"""Return the configuration as a dict"""
221			dictionary = {}
222			for section in self.parser.sections():
223			dictionary[section] = {}
224			for option in self.parser.options(section):
225			dictionary[section][option] = self.parser.get(section, option)
226			return dictionary
227
228			def sections(self):
229			"""Return a list of all sections."""
230			return self.parser.sections()
231
232			def items(self, section):
233			"""Return the items list of a section."""
234			return self.parser.items(section)
235
236			def has_section(self, section):
237			"""Return info about the existence of a section."""
238			return self.parser.has_section(section)
239
240			def set_default_cwc(self, section,
241			option_header=None,
242			cwc=['50', '70', '90']):
243			"""Set default values for careful, warning and critical."""
244			if option_header is None:
245			header = ''
246			else:
247			header = option_header + '_'
248			self.set_default(section, header + 'careful', cwc[0])
249			self.set_default(section, header + 'warning', cwc[1])
250			self.set_default(section, header + 'critical', cwc[2])
251
252			def set_default(self, section, option, default):
253			"""If the option did not exist, create a default value."""
254			if not self.parser.has_option(section, option):
255			self.parser.set(section, option, default)
256
257			def get_value(self, section, option, default=None):
258			"""Get the value of an option, if it exists."""
259			try:
260			return self.parser.get(section, option)
261			except NoOptionError:
262			return default
263
264			def get_int_value(self, section, option, default=0):
265			"""Get the int value of an option, if it exists."""
266			try:
267			return self.parser.getint(section, option)
268			except NoOptionError:
269			return int(default)
270
271			def get_float_value(self, section, option, default=0.0):
272			"""Get the float value of an option, if it exists."""
273			try:
274			return self.parser.getfloat(section, option)
275			except NoOptionError:
276			return float(default)
277

nicolargo / glances

Push — master ( e61e99...a0b053 )

Config.read() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like