579 lines
18 KiB
Python
579 lines
18 KiB
Python
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
|
|
# Use of this source code is governed by a BSD-style license that can be
|
|
# found in the LICENSE file.
|
|
|
|
"""Common objects shared by __init__.py and _ps*.py modules."""
|
|
|
|
# Note: this module is imported by setup.py so it should not import
|
|
# psutil or third-party modules.
|
|
|
|
from __future__ import division
|
|
|
|
import contextlib
|
|
import errno
|
|
import functools
|
|
import os
|
|
import socket
|
|
import stat
|
|
import sys
|
|
import threading
|
|
import warnings
|
|
from collections import defaultdict
|
|
from collections import namedtuple
|
|
from socket import AF_INET
|
|
from socket import SOCK_DGRAM
|
|
from socket import SOCK_STREAM
|
|
try:
|
|
from socket import AF_INET6
|
|
except ImportError:
|
|
AF_INET6 = None
|
|
try:
|
|
from socket import AF_UNIX
|
|
except ImportError:
|
|
AF_UNIX = None
|
|
|
|
if sys.version_info >= (3, 4):
|
|
import enum
|
|
else:
|
|
enum = None
|
|
|
|
# can't take it from _common.py as this script is imported by setup.py
|
|
PY3 = sys.version_info[0] == 3
|
|
|
|
__all__ = [
|
|
# constants
|
|
'FREEBSD', 'BSD', 'LINUX', 'NETBSD', 'OPENBSD', 'MACOS', 'OSX', 'POSIX',
|
|
'SUNOS', 'WINDOWS',
|
|
'ENCODING', 'ENCODING_ERRS', 'AF_INET6',
|
|
# connection constants
|
|
'CONN_CLOSE', 'CONN_CLOSE_WAIT', 'CONN_CLOSING', 'CONN_ESTABLISHED',
|
|
'CONN_FIN_WAIT1', 'CONN_FIN_WAIT2', 'CONN_LAST_ACK', 'CONN_LISTEN',
|
|
'CONN_NONE', 'CONN_SYN_RECV', 'CONN_SYN_SENT', 'CONN_TIME_WAIT',
|
|
# net constants
|
|
'NIC_DUPLEX_FULL', 'NIC_DUPLEX_HALF', 'NIC_DUPLEX_UNKNOWN',
|
|
# process status constants
|
|
'STATUS_DEAD', 'STATUS_DISK_SLEEP', 'STATUS_IDLE', 'STATUS_LOCKED',
|
|
'STATUS_RUNNING', 'STATUS_SLEEPING', 'STATUS_STOPPED', 'STATUS_SUSPENDED',
|
|
'STATUS_TRACING_STOP', 'STATUS_WAITING', 'STATUS_WAKE_KILL',
|
|
'STATUS_WAKING', 'STATUS_ZOMBIE', 'STATUS_PARKED',
|
|
# named tuples
|
|
'pconn', 'pcputimes', 'pctxsw', 'pgids', 'pio', 'pionice', 'popenfile',
|
|
'pthread', 'puids', 'sconn', 'scpustats', 'sdiskio', 'sdiskpart',
|
|
'sdiskusage', 'snetio', 'snicaddr', 'snicstats', 'sswap', 'suser',
|
|
# utility functions
|
|
'conn_tmap', 'deprecated_method', 'isfile_strict', 'memoize',
|
|
'parse_environ_block', 'path_exists_strict', 'usage_percent',
|
|
'supports_ipv6', 'sockfam_to_enum', 'socktype_to_enum', "wrap_numbers",
|
|
]
|
|
|
|
|
|
# ===================================================================
|
|
# --- OS constants
|
|
# ===================================================================
|
|
|
|
|
|
POSIX = os.name == "posix"
|
|
WINDOWS = os.name == "nt"
|
|
LINUX = sys.platform.startswith("linux")
|
|
MACOS = sys.platform.startswith("darwin")
|
|
OSX = MACOS # deprecated alias
|
|
FREEBSD = sys.platform.startswith("freebsd")
|
|
OPENBSD = sys.platform.startswith("openbsd")
|
|
NETBSD = sys.platform.startswith("netbsd")
|
|
BSD = FREEBSD or OPENBSD or NETBSD
|
|
SUNOS = sys.platform.startswith(("sunos", "solaris"))
|
|
AIX = sys.platform.startswith("aix")
|
|
|
|
|
|
# ===================================================================
|
|
# --- API constants
|
|
# ===================================================================
|
|
|
|
|
|
# Process.status()
|
|
STATUS_RUNNING = "running"
|
|
STATUS_SLEEPING = "sleeping"
|
|
STATUS_DISK_SLEEP = "disk-sleep"
|
|
STATUS_STOPPED = "stopped"
|
|
STATUS_TRACING_STOP = "tracing-stop"
|
|
STATUS_ZOMBIE = "zombie"
|
|
STATUS_DEAD = "dead"
|
|
STATUS_WAKE_KILL = "wake-kill"
|
|
STATUS_WAKING = "waking"
|
|
STATUS_IDLE = "idle" # Linux, macOS, FreeBSD
|
|
STATUS_LOCKED = "locked" # FreeBSD
|
|
STATUS_WAITING = "waiting" # FreeBSD
|
|
STATUS_SUSPENDED = "suspended" # NetBSD
|
|
STATUS_PARKED = "parked" # Linux
|
|
|
|
# Process.connections() and psutil.net_connections()
|
|
CONN_ESTABLISHED = "ESTABLISHED"
|
|
CONN_SYN_SENT = "SYN_SENT"
|
|
CONN_SYN_RECV = "SYN_RECV"
|
|
CONN_FIN_WAIT1 = "FIN_WAIT1"
|
|
CONN_FIN_WAIT2 = "FIN_WAIT2"
|
|
CONN_TIME_WAIT = "TIME_WAIT"
|
|
CONN_CLOSE = "CLOSE"
|
|
CONN_CLOSE_WAIT = "CLOSE_WAIT"
|
|
CONN_LAST_ACK = "LAST_ACK"
|
|
CONN_LISTEN = "LISTEN"
|
|
CONN_CLOSING = "CLOSING"
|
|
CONN_NONE = "NONE"
|
|
|
|
# net_if_stats()
|
|
if enum is None:
|
|
NIC_DUPLEX_FULL = 2
|
|
NIC_DUPLEX_HALF = 1
|
|
NIC_DUPLEX_UNKNOWN = 0
|
|
else:
|
|
class NicDuplex(enum.IntEnum):
|
|
NIC_DUPLEX_FULL = 2
|
|
NIC_DUPLEX_HALF = 1
|
|
NIC_DUPLEX_UNKNOWN = 0
|
|
|
|
globals().update(NicDuplex.__members__)
|
|
|
|
# sensors_battery()
|
|
if enum is None:
|
|
POWER_TIME_UNKNOWN = -1
|
|
POWER_TIME_UNLIMITED = -2
|
|
else:
|
|
class BatteryTime(enum.IntEnum):
|
|
POWER_TIME_UNKNOWN = -1
|
|
POWER_TIME_UNLIMITED = -2
|
|
|
|
globals().update(BatteryTime.__members__)
|
|
|
|
# --- others
|
|
|
|
ENCODING = sys.getfilesystemencoding()
|
|
if not PY3:
|
|
ENCODING_ERRS = "replace"
|
|
else:
|
|
try:
|
|
ENCODING_ERRS = sys.getfilesystemencodeerrors() # py 3.6
|
|
except AttributeError:
|
|
ENCODING_ERRS = "surrogateescape" if POSIX else "replace"
|
|
|
|
|
|
# ===================================================================
|
|
# --- namedtuples
|
|
# ===================================================================
|
|
|
|
# --- for system functions
|
|
|
|
# psutil.swap_memory()
|
|
sswap = namedtuple('sswap', ['total', 'used', 'free', 'percent', 'sin',
|
|
'sout'])
|
|
# psutil.disk_usage()
|
|
sdiskusage = namedtuple('sdiskusage', ['total', 'used', 'free', 'percent'])
|
|
# psutil.disk_io_counters()
|
|
sdiskio = namedtuple('sdiskio', ['read_count', 'write_count',
|
|
'read_bytes', 'write_bytes',
|
|
'read_time', 'write_time'])
|
|
# psutil.disk_partitions()
|
|
sdiskpart = namedtuple('sdiskpart', ['device', 'mountpoint', 'fstype', 'opts'])
|
|
# psutil.net_io_counters()
|
|
snetio = namedtuple('snetio', ['bytes_sent', 'bytes_recv',
|
|
'packets_sent', 'packets_recv',
|
|
'errin', 'errout',
|
|
'dropin', 'dropout'])
|
|
# psutil.users()
|
|
suser = namedtuple('suser', ['name', 'terminal', 'host', 'started', 'pid'])
|
|
# psutil.net_connections()
|
|
sconn = namedtuple('sconn', ['fd', 'family', 'type', 'laddr', 'raddr',
|
|
'status', 'pid'])
|
|
# psutil.net_if_addrs()
|
|
snicaddr = namedtuple('snicaddr',
|
|
['family', 'address', 'netmask', 'broadcast', 'ptp'])
|
|
# psutil.net_if_stats()
|
|
snicstats = namedtuple('snicstats', ['isup', 'duplex', 'speed', 'mtu'])
|
|
# psutil.cpu_stats()
|
|
scpustats = namedtuple(
|
|
'scpustats', ['ctx_switches', 'interrupts', 'soft_interrupts', 'syscalls'])
|
|
# psutil.cpu_freq()
|
|
scpufreq = namedtuple('scpufreq', ['current', 'min', 'max'])
|
|
# psutil.sensors_temperatures()
|
|
shwtemp = namedtuple(
|
|
'shwtemp', ['label', 'current', 'high', 'critical'])
|
|
# psutil.sensors_battery()
|
|
sbattery = namedtuple('sbattery', ['percent', 'secsleft', 'power_plugged'])
|
|
# psutil.sensors_fans()
|
|
sfan = namedtuple('sfan', ['label', 'current'])
|
|
|
|
# --- for Process methods
|
|
|
|
# psutil.Process.cpu_times()
|
|
pcputimes = namedtuple('pcputimes',
|
|
['user', 'system', 'children_user', 'children_system'])
|
|
# psutil.Process.open_files()
|
|
popenfile = namedtuple('popenfile', ['path', 'fd'])
|
|
# psutil.Process.threads()
|
|
pthread = namedtuple('pthread', ['id', 'user_time', 'system_time'])
|
|
# psutil.Process.uids()
|
|
puids = namedtuple('puids', ['real', 'effective', 'saved'])
|
|
# psutil.Process.gids()
|
|
pgids = namedtuple('pgids', ['real', 'effective', 'saved'])
|
|
# psutil.Process.io_counters()
|
|
pio = namedtuple('pio', ['read_count', 'write_count',
|
|
'read_bytes', 'write_bytes'])
|
|
# psutil.Process.ionice()
|
|
pionice = namedtuple('pionice', ['ioclass', 'value'])
|
|
# psutil.Process.ctx_switches()
|
|
pctxsw = namedtuple('pctxsw', ['voluntary', 'involuntary'])
|
|
# psutil.Process.connections()
|
|
pconn = namedtuple('pconn', ['fd', 'family', 'type', 'laddr', 'raddr',
|
|
'status'])
|
|
|
|
# psutil.connections() and psutil.Process.connections()
|
|
addr = namedtuple('addr', ['ip', 'port'])
|
|
|
|
|
|
# ===================================================================
|
|
# --- Process.connections() 'kind' parameter mapping
|
|
# ===================================================================
|
|
|
|
|
|
conn_tmap = {
|
|
"all": ([AF_INET, AF_INET6, AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]),
|
|
"tcp": ([AF_INET, AF_INET6], [SOCK_STREAM]),
|
|
"tcp4": ([AF_INET], [SOCK_STREAM]),
|
|
"udp": ([AF_INET, AF_INET6], [SOCK_DGRAM]),
|
|
"udp4": ([AF_INET], [SOCK_DGRAM]),
|
|
"inet": ([AF_INET, AF_INET6], [SOCK_STREAM, SOCK_DGRAM]),
|
|
"inet4": ([AF_INET], [SOCK_STREAM, SOCK_DGRAM]),
|
|
"inet6": ([AF_INET6], [SOCK_STREAM, SOCK_DGRAM]),
|
|
}
|
|
|
|
if AF_INET6 is not None:
|
|
conn_tmap.update({
|
|
"tcp6": ([AF_INET6], [SOCK_STREAM]),
|
|
"udp6": ([AF_INET6], [SOCK_DGRAM]),
|
|
})
|
|
|
|
if AF_UNIX is not None:
|
|
conn_tmap.update({
|
|
"unix": ([AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]),
|
|
})
|
|
|
|
del AF_INET, AF_UNIX, SOCK_STREAM, SOCK_DGRAM
|
|
|
|
|
|
# ===================================================================
|
|
# --- utils
|
|
# ===================================================================
|
|
|
|
|
|
def usage_percent(used, total, round_=None):
|
|
"""Calculate percentage usage of 'used' against 'total'."""
|
|
try:
|
|
ret = (used / total) * 100
|
|
except ZeroDivisionError:
|
|
ret = 0.0 if isinstance(used, float) or isinstance(total, float) else 0
|
|
if round_ is not None:
|
|
return round(ret, round_)
|
|
else:
|
|
return ret
|
|
|
|
|
|
def memoize(fun):
|
|
"""A simple memoize decorator for functions supporting (hashable)
|
|
positional arguments.
|
|
It also provides a cache_clear() function for clearing the cache:
|
|
|
|
>>> @memoize
|
|
... def foo()
|
|
... return 1
|
|
...
|
|
>>> foo()
|
|
1
|
|
>>> foo.cache_clear()
|
|
>>>
|
|
"""
|
|
@functools.wraps(fun)
|
|
def wrapper(*args, **kwargs):
|
|
key = (args, frozenset(sorted(kwargs.items())))
|
|
try:
|
|
return cache[key]
|
|
except KeyError:
|
|
ret = cache[key] = fun(*args, **kwargs)
|
|
return ret
|
|
|
|
def cache_clear():
|
|
"""Clear cache."""
|
|
cache.clear()
|
|
|
|
cache = {}
|
|
wrapper.cache_clear = cache_clear
|
|
return wrapper
|
|
|
|
|
|
def memoize_when_activated(fun):
|
|
"""A memoize decorator which is disabled by default. It can be
|
|
activated and deactivated on request.
|
|
For efficiency reasons it can be used only against class methods
|
|
accepting no arguments.
|
|
|
|
>>> class Foo:
|
|
... @memoize
|
|
... def foo()
|
|
... print(1)
|
|
...
|
|
>>> f = Foo()
|
|
>>> # deactivated (default)
|
|
>>> foo()
|
|
1
|
|
>>> foo()
|
|
1
|
|
>>>
|
|
>>> # activated
|
|
>>> foo.cache_activate()
|
|
>>> foo()
|
|
1
|
|
>>> foo()
|
|
>>> foo()
|
|
>>>
|
|
"""
|
|
@functools.wraps(fun)
|
|
def wrapper(self):
|
|
if not wrapper.cache_activated:
|
|
return fun(self)
|
|
else:
|
|
try:
|
|
ret = cache[fun]
|
|
except KeyError:
|
|
ret = cache[fun] = fun(self)
|
|
return ret
|
|
|
|
def cache_activate():
|
|
"""Activate cache."""
|
|
wrapper.cache_activated = True
|
|
|
|
def cache_deactivate():
|
|
"""Deactivate and clear cache."""
|
|
wrapper.cache_activated = False
|
|
cache.clear()
|
|
|
|
cache = {}
|
|
wrapper.cache_activated = False
|
|
wrapper.cache_activate = cache_activate
|
|
wrapper.cache_deactivate = cache_deactivate
|
|
return wrapper
|
|
|
|
|
|
def isfile_strict(path):
|
|
"""Same as os.path.isfile() but does not swallow EACCES / EPERM
|
|
exceptions, see:
|
|
http://mail.python.org/pipermail/python-dev/2012-June/120787.html
|
|
"""
|
|
try:
|
|
st = os.stat(path)
|
|
except OSError as err:
|
|
if err.errno in (errno.EPERM, errno.EACCES):
|
|
raise
|
|
return False
|
|
else:
|
|
return stat.S_ISREG(st.st_mode)
|
|
|
|
|
|
def path_exists_strict(path):
|
|
"""Same as os.path.exists() but does not swallow EACCES / EPERM
|
|
exceptions, see:
|
|
http://mail.python.org/pipermail/python-dev/2012-June/120787.html
|
|
"""
|
|
try:
|
|
os.stat(path)
|
|
except OSError as err:
|
|
if err.errno in (errno.EPERM, errno.EACCES):
|
|
raise
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
|
|
@memoize
|
|
def supports_ipv6():
|
|
"""Return True if IPv6 is supported on this platform."""
|
|
if not socket.has_ipv6 or AF_INET6 is None:
|
|
return False
|
|
try:
|
|
sock = socket.socket(AF_INET6, socket.SOCK_STREAM)
|
|
with contextlib.closing(sock):
|
|
sock.bind(("::1", 0))
|
|
return True
|
|
except socket.error:
|
|
return False
|
|
|
|
|
|
def parse_environ_block(data):
|
|
"""Parse a C environ block of environment variables into a dictionary."""
|
|
# The block is usually raw data from the target process. It might contain
|
|
# trailing garbage and lines that do not look like assignments.
|
|
ret = {}
|
|
pos = 0
|
|
|
|
# localize global variable to speed up access.
|
|
WINDOWS_ = WINDOWS
|
|
while True:
|
|
next_pos = data.find("\0", pos)
|
|
# nul byte at the beginning or double nul byte means finish
|
|
if next_pos <= pos:
|
|
break
|
|
# there might not be an equals sign
|
|
equal_pos = data.find("=", pos, next_pos)
|
|
if equal_pos > pos:
|
|
key = data[pos:equal_pos]
|
|
value = data[equal_pos + 1:next_pos]
|
|
# Windows expects environment variables to be uppercase only
|
|
if WINDOWS_:
|
|
key = key.upper()
|
|
ret[key] = value
|
|
pos = next_pos + 1
|
|
|
|
return ret
|
|
|
|
|
|
def sockfam_to_enum(num):
|
|
"""Convert a numeric socket family value to an IntEnum member.
|
|
If it's not a known member, return the numeric value itself.
|
|
"""
|
|
if enum is None:
|
|
return num
|
|
else: # pragma: no cover
|
|
try:
|
|
return socket.AddressFamily(num)
|
|
except (ValueError, AttributeError):
|
|
return num
|
|
|
|
|
|
def socktype_to_enum(num):
|
|
"""Convert a numeric socket type value to an IntEnum member.
|
|
If it's not a known member, return the numeric value itself.
|
|
"""
|
|
if enum is None:
|
|
return num
|
|
else: # pragma: no cover
|
|
try:
|
|
return socket.AddressType(num)
|
|
except (ValueError, AttributeError):
|
|
return num
|
|
|
|
|
|
def deprecated_method(replacement):
|
|
"""A decorator which can be used to mark a method as deprecated
|
|
'replcement' is the method name which will be called instead.
|
|
"""
|
|
def outer(fun):
|
|
msg = "%s() is deprecated and will be removed; use %s() instead" % (
|
|
fun.__name__, replacement)
|
|
if fun.__doc__ is None:
|
|
fun.__doc__ = msg
|
|
|
|
@functools.wraps(fun)
|
|
def inner(self, *args, **kwargs):
|
|
warnings.warn(msg, category=FutureWarning, stacklevel=2)
|
|
return getattr(self, replacement)(*args, **kwargs)
|
|
return inner
|
|
return outer
|
|
|
|
|
|
class _WrapNumbers:
|
|
"""Watches numbers so that they don't overflow and wrap
|
|
(reset to zero).
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.lock = threading.Lock()
|
|
self.cache = {}
|
|
self.reminders = {}
|
|
self.reminder_keys = {}
|
|
|
|
def _add_dict(self, input_dict, name):
|
|
assert name not in self.cache
|
|
assert name not in self.reminders
|
|
assert name not in self.reminder_keys
|
|
self.cache[name] = input_dict
|
|
self.reminders[name] = defaultdict(int)
|
|
self.reminder_keys[name] = defaultdict(set)
|
|
|
|
def _remove_dead_reminders(self, input_dict, name):
|
|
"""In case the number of keys changed between calls (e.g. a
|
|
disk disappears) this removes the entry from self.reminders.
|
|
"""
|
|
old_dict = self.cache[name]
|
|
gone_keys = set(old_dict.keys()) - set(input_dict.keys())
|
|
for gone_key in gone_keys:
|
|
for remkey in self.reminder_keys[name][gone_key]:
|
|
del self.reminders[name][remkey]
|
|
del self.reminder_keys[name][gone_key]
|
|
|
|
def run(self, input_dict, name):
|
|
"""Cache dict and sum numbers which overflow and wrap.
|
|
Return an updated copy of `input_dict`
|
|
"""
|
|
if name not in self.cache:
|
|
# This was the first call.
|
|
self._add_dict(input_dict, name)
|
|
return input_dict
|
|
|
|
self._remove_dead_reminders(input_dict, name)
|
|
|
|
old_dict = self.cache[name]
|
|
new_dict = {}
|
|
for key in input_dict.keys():
|
|
input_tuple = input_dict[key]
|
|
try:
|
|
old_tuple = old_dict[key]
|
|
except KeyError:
|
|
# The input dict has a new key (e.g. a new disk or NIC)
|
|
# which didn't exist in the previous call.
|
|
new_dict[key] = input_tuple
|
|
continue
|
|
|
|
bits = []
|
|
for i in range(len(input_tuple)):
|
|
input_value = input_tuple[i]
|
|
old_value = old_tuple[i]
|
|
remkey = (key, i)
|
|
if input_value < old_value:
|
|
# it wrapped!
|
|
self.reminders[name][remkey] += old_value
|
|
self.reminder_keys[name][key].add(remkey)
|
|
bits.append(input_value + self.reminders[name][remkey])
|
|
|
|
new_dict[key] = tuple(bits)
|
|
|
|
self.cache[name] = input_dict
|
|
return new_dict
|
|
|
|
def cache_clear(self, name=None):
|
|
"""Clear the internal cache, optionally only for function 'name'."""
|
|
with self.lock:
|
|
if name is None:
|
|
self.cache.clear()
|
|
self.reminders.clear()
|
|
self.reminder_keys.clear()
|
|
else:
|
|
self.cache.pop(name, None)
|
|
self.reminders.pop(name, None)
|
|
self.reminder_keys.pop(name, None)
|
|
|
|
def cache_info(self):
|
|
"""Return internal cache dicts as a tuple of 3 elements."""
|
|
with self.lock:
|
|
return (self.cache, self.reminders, self.reminder_keys)
|
|
|
|
|
|
def wrap_numbers(input_dict, name):
|
|
"""Given an `input_dict` and a function `name`, adjust the numbers
|
|
which "wrap" (restart from zero) across different calls by adding
|
|
"old value" to "new value" and return an updated dict.
|
|
"""
|
|
with _wn.lock:
|
|
return _wn.run(input_dict, name)
|
|
|
|
|
|
_wn = _WrapNumbers()
|
|
wrap_numbers.cache_clear = _wn.cache_clear
|
|
wrap_numbers.cache_info = _wn.cache_info
|