# -*- coding: utf-8 -*- # # This file is part of Glances. # # SPDX-FileCopyrightText: 2022 Nicolas Hennion <nicolas@nicolargo.com> # # SPDX-License-Identifier: LGPL-3.0-only # import re from glances.logger import logger class GlancesFilter(object): """Allow Glances to filter processes >>> f = GlancesFilter() >>> f.filter = '.*python.*' >>> f.filter '.*python.*' >>> f.key None >>> f.filter = 'user:nicolargo' >>> f.filter 'nicolargo' >>> f.key 'user' >>> f.filter = 'username:.*nico.*' >>> f.filter '.*nico.*' >>> f.key 'username' """ def __init__(self): # Filter entered by the user (string) self._filter_input = None # Filter to apply self._filter = None # Filter regular expression self._filter_re = None # Dict key where the filter should be applied # Default is None: search on command line and process name self._filter_key = None @property def filter_input(self): """Return the filter given by the user (as a string)""" return self._filter_input @property def filter(self): """Return the current filter to be applied""" return self._filter @filter.setter def filter(self, value): """Set the filter (as a string) and compute the regular expression A filter could be one of the following: - python > Process name of cmd start with python - .*python.* > Process name of cmd contain python - username:nicolargo > Process of nicolargo user """ self._filter_input = value if value is None: self._filter = None self._filter_key = None else: new_filter = value.split(':') if len(new_filter) == 1: self._filter = new_filter[0] self._filter_key = None else: self._filter = new_filter[1] self._filter_key = new_filter[0] self._filter_re = None if self.filter is not None: logger.info("Set filter to {} on key {}".format(self.filter, self.filter_key)) # Compute the regular expression try: self._filter_re = re.compile(self.filter) logger.debug("Filter regex compilation OK: {}".format(self.filter)) except Exception as e: logger.error("Cannot compile filter regex: {} ({})".format(self.filter, e)) self._filter = None self._filter_re = None self._filter_key = None @property def filter_re(self): """Return the filter regular expression""" return self._filter_re @property def filter_key(self): """key where the filter should be applied""" return self._filter_key def is_filtered(self, process): """Return True if the process item match the current filter :param process: A dict corresponding to the process item. """ if self.filter is None: # No filter => Not filtered return False if self.filter_key is None: # Apply filter on command line and process name return self._is_process_filtered(process, key='name') or self._is_process_filtered(process, key='cmdline') else: # Apply filter on <key> return self._is_process_filtered(process) def _is_process_filtered(self, process, key=None): """Return True if the process[key] should be filtered according to the current filter""" if key is None: key = self.filter_key try: # If the item process[key] is a list, convert it to a string # in order to match it with the current regular expression if isinstance(process[key], list): value = ' '.join(process[key]) else: value = process[key] except KeyError: # If the key did not exist return False try: return self._filter_re.fullmatch(value) is None except (AttributeError, TypeError): # AttributeError - Filter processes crashes with a bad regular expression pattern (issue #665) # TypeError - Filter processes crashes if value is None (issue #1105) return False