mirror of
https://github.com/nicolargo/glances.git
synced 2026-05-04 20:56:31 -04:00
139 lines
4.3 KiB
Python
139 lines
4.3 KiB
Python
# -*- 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
|