install psutil
This commit is contained in:
parent
81bfe1e37a
commit
9ba1a1290a
|
@ -0,0 +1 @@
|
|||
pip
|
|
@ -0,0 +1,29 @@
|
|||
BSD 3-Clause License
|
||||
|
||||
Copyright (c) 2009, Jay Loden, Dave Daeschler, Giampaolo Rodola
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the psutil authors nor the names of its contributors
|
||||
may be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
@ -0,0 +1,529 @@
|
|||
Metadata-Version: 2.1
|
||||
Name: psutil
|
||||
Version: 5.9.5
|
||||
Summary: Cross-platform lib for process and system monitoring in Python.
|
||||
Home-page: https://github.com/giampaolo/psutil
|
||||
Author: Giampaolo Rodola
|
||||
Author-email: g.rodola@gmail.com
|
||||
License: BSD-3-Clause
|
||||
Keywords: ps,top,kill,free,lsof,netstat,nice,tty,ionice,uptime,taskmgr,process,df,iotop,iostat,ifconfig,taskset,who,pidof,pmap,smem,pstree,monitoring,ulimit,prlimit,smem,performance,metrics,agent,observability
|
||||
Platform: Platform Independent
|
||||
Classifier: Development Status :: 5 - Production/Stable
|
||||
Classifier: Environment :: Console
|
||||
Classifier: Environment :: Win32 (MS Windows)
|
||||
Classifier: Intended Audience :: Developers
|
||||
Classifier: Intended Audience :: Information Technology
|
||||
Classifier: Intended Audience :: System Administrators
|
||||
Classifier: License :: OSI Approved :: BSD License
|
||||
Classifier: Operating System :: MacOS :: MacOS X
|
||||
Classifier: Operating System :: Microsoft :: Windows :: Windows 10
|
||||
Classifier: Operating System :: Microsoft :: Windows :: Windows 7
|
||||
Classifier: Operating System :: Microsoft :: Windows :: Windows 8
|
||||
Classifier: Operating System :: Microsoft :: Windows :: Windows 8.1
|
||||
Classifier: Operating System :: Microsoft :: Windows :: Windows Server 2003
|
||||
Classifier: Operating System :: Microsoft :: Windows :: Windows Server 2008
|
||||
Classifier: Operating System :: Microsoft :: Windows :: Windows Vista
|
||||
Classifier: Operating System :: Microsoft
|
||||
Classifier: Operating System :: OS Independent
|
||||
Classifier: Operating System :: POSIX :: AIX
|
||||
Classifier: Operating System :: POSIX :: BSD :: FreeBSD
|
||||
Classifier: Operating System :: POSIX :: BSD :: NetBSD
|
||||
Classifier: Operating System :: POSIX :: BSD :: OpenBSD
|
||||
Classifier: Operating System :: POSIX :: BSD
|
||||
Classifier: Operating System :: POSIX :: Linux
|
||||
Classifier: Operating System :: POSIX :: SunOS/Solaris
|
||||
Classifier: Operating System :: POSIX
|
||||
Classifier: Programming Language :: C
|
||||
Classifier: Programming Language :: Python :: 2
|
||||
Classifier: Programming Language :: Python :: 2.7
|
||||
Classifier: Programming Language :: Python :: 3
|
||||
Classifier: Programming Language :: Python :: Implementation :: CPython
|
||||
Classifier: Programming Language :: Python :: Implementation :: PyPy
|
||||
Classifier: Programming Language :: Python
|
||||
Classifier: Topic :: Software Development :: Libraries :: Python Modules
|
||||
Classifier: Topic :: Software Development :: Libraries
|
||||
Classifier: Topic :: System :: Benchmark
|
||||
Classifier: Topic :: System :: Hardware :: Hardware Drivers
|
||||
Classifier: Topic :: System :: Hardware
|
||||
Classifier: Topic :: System :: Monitoring
|
||||
Classifier: Topic :: System :: Networking :: Monitoring :: Hardware Watchdog
|
||||
Classifier: Topic :: System :: Networking :: Monitoring
|
||||
Classifier: Topic :: System :: Networking
|
||||
Classifier: Topic :: System :: Operating System
|
||||
Classifier: Topic :: System :: Systems Administration
|
||||
Classifier: Topic :: Utilities
|
||||
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
|
||||
Description-Content-Type: text/x-rst
|
||||
Provides-Extra: test
|
||||
Requires-Dist: ipaddress ; (python_version < "3.0") and extra == 'test'
|
||||
Requires-Dist: mock ; (python_version < "3.0") and extra == 'test'
|
||||
Requires-Dist: enum34 ; (python_version <= "3.4") and extra == 'test'
|
||||
Requires-Dist: pywin32 ; (sys_platform == "win32") and extra == 'test'
|
||||
Requires-Dist: wmi ; (sys_platform == "win32") and extra == 'test'
|
||||
|
||||
| |downloads| |stars| |forks| |contributors| |coverage|
|
||||
| |version| |py-versions| |packages| |license|
|
||||
| |github-actions-wheels| |github-actions-bsd| |appveyor| |doc| |twitter| |tidelift|
|
||||
|
||||
.. |downloads| image:: https://img.shields.io/pypi/dm/psutil.svg
|
||||
:target: https://pepy.tech/project/psutil
|
||||
:alt: Downloads
|
||||
|
||||
.. |stars| image:: https://img.shields.io/github/stars/giampaolo/psutil.svg
|
||||
:target: https://github.com/giampaolo/psutil/stargazers
|
||||
:alt: Github stars
|
||||
|
||||
.. |forks| image:: https://img.shields.io/github/forks/giampaolo/psutil.svg
|
||||
:target: https://github.com/giampaolo/psutil/network/members
|
||||
:alt: Github forks
|
||||
|
||||
.. |contributors| image:: https://img.shields.io/github/contributors/giampaolo/psutil.svg
|
||||
:target: https://github.com/giampaolo/psutil/graphs/contributors
|
||||
:alt: Contributors
|
||||
|
||||
.. |github-actions-wheels| image:: https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/build.yml?label=Linux%2C%20macOS%2C%20Windows
|
||||
:target: https://github.com/giampaolo/psutil/actions?query=workflow%3Abuild
|
||||
:alt: Linux, macOS, Windows
|
||||
|
||||
.. |github-actions-bsd| image:: https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/bsd.yml?label=FreeBSD,%20NetBSD,%20OpenBSD
|
||||
:target: https://github.com/giampaolo/psutil/actions?query=workflow%3Absd-tests
|
||||
:alt: FreeBSD, NetBSD, OpenBSD
|
||||
|
||||
.. |appveyor| image:: https://img.shields.io/appveyor/build/giampaolo/psutil/master.svg?maxAge=3600&label=Windows%20(py2)
|
||||
:target: https://ci.appveyor.com/project/giampaolo/psutil
|
||||
:alt: Windows (Appveyor)
|
||||
|
||||
.. |coverage| image:: https://coveralls.io/repos/github/giampaolo/psutil/badge.svg?branch=master
|
||||
:target: https://coveralls.io/github/giampaolo/psutil?branch=master
|
||||
:alt: Test coverage (coverall.io)
|
||||
|
||||
.. |doc| image:: https://readthedocs.org/projects/psutil/badge/?version=latest
|
||||
:target: https://psutil.readthedocs.io/en/latest/
|
||||
:alt: Documentation Status
|
||||
|
||||
.. |version| image:: https://img.shields.io/pypi/v/psutil.svg?label=pypi
|
||||
:target: https://pypi.org/project/psutil
|
||||
:alt: Latest version
|
||||
|
||||
.. |py-versions| image:: https://img.shields.io/pypi/pyversions/psutil.svg
|
||||
:alt: Supported Python versions
|
||||
|
||||
.. |packages| image:: https://repology.org/badge/tiny-repos/python:psutil.svg
|
||||
:target: https://repology.org/metapackage/python:psutil/versions
|
||||
:alt: Binary packages
|
||||
|
||||
.. |license| image:: https://img.shields.io/pypi/l/psutil.svg
|
||||
:target: https://github.com/giampaolo/psutil/blob/master/LICENSE
|
||||
:alt: License
|
||||
|
||||
.. |twitter| image:: https://img.shields.io/twitter/follow/grodola.svg?label=follow&style=flat&logo=twitter&logoColor=4FADFF
|
||||
:target: https://twitter.com/grodola
|
||||
:alt: Twitter Follow
|
||||
|
||||
.. |tidelift| image:: https://tidelift.com/badges/github/giampaolo/psutil?style=flat
|
||||
:target: https://tidelift.com/subscription/pkg/pypi-psutil?utm_source=pypi-psutil&utm_medium=referral&utm_campaign=readme
|
||||
:alt: Tidelift
|
||||
|
||||
-----
|
||||
|
||||
Quick links
|
||||
===========
|
||||
|
||||
- `Home page <https://github.com/giampaolo/psutil>`_
|
||||
- `Install <https://github.com/giampaolo/psutil/blob/master/INSTALL.rst>`_
|
||||
- `Documentation <http://psutil.readthedocs.io>`_
|
||||
- `Download <https://pypi.org/project/psutil/#files>`_
|
||||
- `Forum <http://groups.google.com/group/psutil/topics>`_
|
||||
- `StackOverflow <https://stackoverflow.com/questions/tagged/psutil>`_
|
||||
- `Blog <https://gmpy.dev/tags/psutil>`_
|
||||
- `What's new <https://github.com/giampaolo/psutil/blob/master/HISTORY.rst>`_
|
||||
|
||||
|
||||
Summary
|
||||
=======
|
||||
|
||||
psutil (process and system utilities) is a cross-platform library for
|
||||
retrieving information on **running processes** and **system utilization**
|
||||
(CPU, memory, disks, network, sensors) in Python.
|
||||
It is useful mainly for **system monitoring**, **profiling and limiting process
|
||||
resources** and **management of running processes**.
|
||||
It implements many functionalities offered by classic UNIX command line tools
|
||||
such as *ps, top, iotop, lsof, netstat, ifconfig, free* and others.
|
||||
psutil currently supports the following platforms:
|
||||
|
||||
- **Linux**
|
||||
- **Windows**
|
||||
- **macOS**
|
||||
- **FreeBSD, OpenBSD**, **NetBSD**
|
||||
- **Sun Solaris**
|
||||
- **AIX**
|
||||
|
||||
Supported Python versions are **2.7**, **3.4+** and
|
||||
`PyPy <http://pypy.org/>`__.
|
||||
|
||||
Funding
|
||||
=======
|
||||
|
||||
While psutil is free software and will always be, the project would benefit
|
||||
immensely from some funding.
|
||||
Keeping up with bug reports and maintenance has become hardly sustainable for
|
||||
me alone in terms of time.
|
||||
If you're a company that's making significant use of psutil you can consider
|
||||
becoming a sponsor via `GitHub Sponsors <https://github.com/sponsors/giampaolo>`__,
|
||||
`Open Collective <https://opencollective.com/psutil>`__ or
|
||||
`PayPal <https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=A9ZS7PKKRM3S8>`__
|
||||
and have your logo displayed in here and psutil `doc <https://psutil.readthedocs.io>`__.
|
||||
|
||||
Sponsors
|
||||
========
|
||||
|
||||
.. image:: https://github.com/giampaolo/psutil/raw/master/docs/_static/tidelift-logo.png
|
||||
:width: 200
|
||||
:alt: Alternative text
|
||||
|
||||
`Add your logo <https://github.com/sponsors/giampaolo>`__.
|
||||
|
||||
Example usages
|
||||
==============
|
||||
|
||||
This represents pretty much the whole psutil API.
|
||||
|
||||
CPU
|
||||
---
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> import psutil
|
||||
>>>
|
||||
>>> psutil.cpu_times()
|
||||
scputimes(user=3961.46, nice=169.729, system=2150.659, idle=16900.540, iowait=629.59, irq=0.0, softirq=19.42, steal=0.0, guest=0, nice=0.0)
|
||||
>>>
|
||||
>>> for x in range(3):
|
||||
... psutil.cpu_percent(interval=1)
|
||||
...
|
||||
4.0
|
||||
5.9
|
||||
3.8
|
||||
>>>
|
||||
>>> for x in range(3):
|
||||
... psutil.cpu_percent(interval=1, percpu=True)
|
||||
...
|
||||
[4.0, 6.9, 3.7, 9.2]
|
||||
[7.0, 8.5, 2.4, 2.1]
|
||||
[1.2, 9.0, 9.9, 7.2]
|
||||
>>>
|
||||
>>> for x in range(3):
|
||||
... psutil.cpu_times_percent(interval=1, percpu=False)
|
||||
...
|
||||
scputimes(user=1.5, nice=0.0, system=0.5, idle=96.5, iowait=1.5, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
|
||||
scputimes(user=1.0, nice=0.0, system=0.0, idle=99.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
|
||||
scputimes(user=2.0, nice=0.0, system=0.0, idle=98.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
|
||||
>>>
|
||||
>>> psutil.cpu_count()
|
||||
4
|
||||
>>> psutil.cpu_count(logical=False)
|
||||
2
|
||||
>>>
|
||||
>>> psutil.cpu_stats()
|
||||
scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
|
||||
>>>
|
||||
>>> psutil.cpu_freq()
|
||||
scpufreq(current=931.42925, min=800.0, max=3500.0)
|
||||
>>>
|
||||
>>> psutil.getloadavg() # also on Windows (emulated)
|
||||
(3.14, 3.89, 4.67)
|
||||
|
||||
Memory
|
||||
------
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> psutil.virtual_memory()
|
||||
svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, active=4748992512, inactive=2758115328, buffers=790724608, cached=3500347392, shared=787554304)
|
||||
>>> psutil.swap_memory()
|
||||
sswap(total=2097147904, used=296128512, free=1801019392, percent=14.1, sin=304193536, sout=677842944)
|
||||
>>>
|
||||
|
||||
Disks
|
||||
-----
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> psutil.disk_partitions()
|
||||
[sdiskpart(device='/dev/sda1', mountpoint='/', fstype='ext4', opts='rw,nosuid', maxfile=255, maxpath=4096),
|
||||
sdiskpart(device='/dev/sda2', mountpoint='/home', fstype='ext', opts='rw', maxfile=255, maxpath=4096)]
|
||||
>>>
|
||||
>>> psutil.disk_usage('/')
|
||||
sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
|
||||
>>>
|
||||
>>> psutil.disk_io_counters(perdisk=False)
|
||||
sdiskio(read_count=719566, write_count=1082197, read_bytes=18626220032, write_bytes=24081764352, read_time=5023392, write_time=63199568, read_merged_count=619166, write_merged_count=812396, busy_time=4523412)
|
||||
>>>
|
||||
|
||||
Network
|
||||
-------
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> psutil.net_io_counters(pernic=True)
|
||||
{'eth0': netio(bytes_sent=485291293, bytes_recv=6004858642, packets_sent=3251564, packets_recv=4787798, errin=0, errout=0, dropin=0, dropout=0),
|
||||
'lo': netio(bytes_sent=2838627, bytes_recv=2838627, packets_sent=30567, packets_recv=30567, errin=0, errout=0, dropin=0, dropout=0)}
|
||||
>>>
|
||||
>>> psutil.net_connections(kind='tcp')
|
||||
[sconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED', pid=1254),
|
||||
sconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status='CLOSING', pid=2987),
|
||||
...]
|
||||
>>>
|
||||
>>> psutil.net_if_addrs()
|
||||
{'lo': [snicaddr(family=<AddressFamily.AF_INET: 2>, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None),
|
||||
snicaddr(family=<AddressFamily.AF_INET6: 10>, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None),
|
||||
snicaddr(family=<AddressFamily.AF_LINK: 17>, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)],
|
||||
'wlan0': [snicaddr(family=<AddressFamily.AF_INET: 2>, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None),
|
||||
snicaddr(family=<AddressFamily.AF_INET6: 10>, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None),
|
||||
snicaddr(family=<AddressFamily.AF_LINK: 17>, address='c4:85:08:45:06:41', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]}
|
||||
>>>
|
||||
>>> psutil.net_if_stats()
|
||||
{'lo': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>, speed=0, mtu=65536, flags='up,loopback,running'),
|
||||
'wlan0': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=100, mtu=1500, flags='up,broadcast,running,multicast')}
|
||||
>>>
|
||||
|
||||
Sensors
|
||||
-------
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> import psutil
|
||||
>>> psutil.sensors_temperatures()
|
||||
{'acpitz': [shwtemp(label='', current=47.0, high=103.0, critical=103.0)],
|
||||
'asus': [shwtemp(label='', current=47.0, high=None, critical=None)],
|
||||
'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
|
||||
shwtemp(label='Core 0', current=45.0, high=100.0, critical=100.0)]}
|
||||
>>>
|
||||
>>> psutil.sensors_fans()
|
||||
{'asus': [sfan(label='cpu_fan', current=3200)]}
|
||||
>>>
|
||||
>>> psutil.sensors_battery()
|
||||
sbattery(percent=93, secsleft=16628, power_plugged=False)
|
||||
>>>
|
||||
|
||||
Other system info
|
||||
-----------------
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> import psutil
|
||||
>>> psutil.users()
|
||||
[suser(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0, pid=1352),
|
||||
suser(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0, pid=1788)]
|
||||
>>>
|
||||
>>> psutil.boot_time()
|
||||
1365519115.0
|
||||
>>>
|
||||
|
||||
Process management
|
||||
------------------
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> import psutil
|
||||
>>> psutil.pids()
|
||||
[1, 2, 3, 4, 5, 6, 7, 46, 48, 50, 51, 178, 182, 222, 223, 224, 268, 1215,
|
||||
1216, 1220, 1221, 1243, 1244, 1301, 1601, 2237, 2355, 2637, 2774, 3932,
|
||||
4176, 4177, 4185, 4187, 4189, 4225, 4243, 4245, 4263, 4282, 4306, 4311,
|
||||
4312, 4313, 4314, 4337, 4339, 4357, 4358, 4363, 4383, 4395, 4408, 4433,
|
||||
4443, 4445, 4446, 5167, 5234, 5235, 5252, 5318, 5424, 5644, 6987, 7054,
|
||||
7055, 7071]
|
||||
>>>
|
||||
>>> p = psutil.Process(7055)
|
||||
>>> p
|
||||
psutil.Process(pid=7055, name='python3', status='running', started='09:04:44')
|
||||
>>> p.name()
|
||||
'python3'
|
||||
>>> p.exe()
|
||||
'/usr/bin/python3'
|
||||
>>> p.cwd()
|
||||
'/home/giampaolo'
|
||||
>>> p.cmdline()
|
||||
['/usr/bin/python', 'main.py']
|
||||
>>>
|
||||
>>> p.pid
|
||||
7055
|
||||
>>> p.ppid()
|
||||
7054
|
||||
>>> p.children(recursive=True)
|
||||
[psutil.Process(pid=29835, name='python3', status='sleeping', started='11:45:38'),
|
||||
psutil.Process(pid=29836, name='python3', status='waking', started='11:43:39')]
|
||||
>>>
|
||||
>>> p.parent()
|
||||
psutil.Process(pid=4699, name='bash', status='sleeping', started='09:06:44')
|
||||
>>> p.parents()
|
||||
[psutil.Process(pid=4699, name='bash', started='09:06:44'),
|
||||
psutil.Process(pid=4689, name='gnome-terminal-server', status='sleeping', started='0:06:44'),
|
||||
psutil.Process(pid=1, name='systemd', status='sleeping', started='05:56:55')]
|
||||
>>>
|
||||
>>> p.status()
|
||||
'running'
|
||||
>>> p.username()
|
||||
'giampaolo'
|
||||
>>> p.create_time()
|
||||
1267551141.5019531
|
||||
>>> p.terminal()
|
||||
'/dev/pts/0'
|
||||
>>>
|
||||
>>> p.uids()
|
||||
puids(real=1000, effective=1000, saved=1000)
|
||||
>>> p.gids()
|
||||
pgids(real=1000, effective=1000, saved=1000)
|
||||
>>>
|
||||
>>> p.cpu_times()
|
||||
pcputimes(user=1.02, system=0.31, children_user=0.32, children_system=0.1, iowait=0.0)
|
||||
>>> p.cpu_percent(interval=1.0)
|
||||
12.1
|
||||
>>> p.cpu_affinity()
|
||||
[0, 1, 2, 3]
|
||||
>>> p.cpu_affinity([0, 1]) # set
|
||||
>>> p.cpu_num()
|
||||
1
|
||||
>>>
|
||||
>>> p.memory_info()
|
||||
pmem(rss=10915840, vms=67608576, shared=3313664, text=2310144, lib=0, data=7262208, dirty=0)
|
||||
>>> p.memory_full_info() # "real" USS memory usage (Linux, macOS, Win only)
|
||||
pfullmem(rss=10199040, vms=52133888, shared=3887104, text=2867200, lib=0, data=5967872, dirty=0, uss=6545408, pss=6872064, swap=0)
|
||||
>>> p.memory_percent()
|
||||
0.7823
|
||||
>>> p.memory_maps()
|
||||
[pmmap_grouped(path='/lib/x8664-linux-gnu/libutil-2.15.so', rss=32768, size=2125824, pss=32768, shared_clean=0, shared_dirty=0, private_clean=20480, private_dirty=12288, referenced=32768, anonymous=12288, swap=0),
|
||||
pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so', rss=3821568, size=3842048, pss=3821568, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=3821568, referenced=3575808, anonymous=3821568, swap=0),
|
||||
pmmap_grouped(path='[heap]', rss=32768, size=139264, pss=32768, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=32768, referenced=32768, anonymous=32768, swap=0),
|
||||
pmmap_grouped(path='[stack]', rss=2465792, size=2494464, pss=2465792, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=2465792, referenced=2277376, anonymous=2465792, swap=0),
|
||||
...]
|
||||
>>>
|
||||
>>> p.io_counters()
|
||||
pio(read_count=478001, write_count=59371, read_bytes=700416, write_bytes=69632, read_chars=456232, write_chars=517543)
|
||||
>>>
|
||||
>>> p.open_files()
|
||||
[popenfile(path='/home/giampaolo/monit.py', fd=3, position=0, mode='r', flags=32768),
|
||||
popenfile(path='/var/log/monit.log', fd=4, position=235542, mode='a', flags=33793)]
|
||||
>>>
|
||||
>>> p.connections(kind='tcp')
|
||||
[pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED'),
|
||||
pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status='CLOSING')]
|
||||
>>>
|
||||
>>> p.num_threads()
|
||||
4
|
||||
>>> p.num_fds()
|
||||
8
|
||||
>>> p.threads()
|
||||
[pthread(id=5234, user_time=22.5, system_time=9.2891),
|
||||
pthread(id=5237, user_time=0.0707, system_time=1.1)]
|
||||
>>>
|
||||
>>> p.num_ctx_switches()
|
||||
pctxsw(voluntary=78, involuntary=19)
|
||||
>>>
|
||||
>>> p.nice()
|
||||
0
|
||||
>>> p.nice(10) # set
|
||||
>>>
|
||||
>>> p.ionice(psutil.IOPRIO_CLASS_IDLE) # IO priority (Win and Linux only)
|
||||
>>> p.ionice()
|
||||
pionice(ioclass=<IOPriority.IOPRIO_CLASS_IDLE: 3>, value=0)
|
||||
>>>
|
||||
>>> p.rlimit(psutil.RLIMIT_NOFILE, (5, 5)) # set resource limits (Linux only)
|
||||
>>> p.rlimit(psutil.RLIMIT_NOFILE)
|
||||
(5, 5)
|
||||
>>>
|
||||
>>> p.environ()
|
||||
{'LC_PAPER': 'it_IT.UTF-8', 'SHELL': '/bin/bash', 'GREP_OPTIONS': '--color=auto',
|
||||
'XDG_CONFIG_DIRS': '/etc/xdg/xdg-ubuntu:/usr/share/upstart/xdg:/etc/xdg',
|
||||
...}
|
||||
>>>
|
||||
>>> p.as_dict()
|
||||
{'status': 'running', 'num_ctx_switches': pctxsw(voluntary=63, involuntary=1), 'pid': 5457, ...}
|
||||
>>> p.is_running()
|
||||
True
|
||||
>>> p.suspend()
|
||||
>>> p.resume()
|
||||
>>>
|
||||
>>> p.terminate()
|
||||
>>> p.kill()
|
||||
>>> p.wait(timeout=3)
|
||||
<Exitcode.EX_OK: 0>
|
||||
>>>
|
||||
>>> psutil.test()
|
||||
USER PID %CPU %MEM VSZ RSS TTY START TIME COMMAND
|
||||
root 1 0.0 0.0 24584 2240 Jun17 00:00 init
|
||||
root 2 0.0 0.0 0 0 Jun17 00:00 kthreadd
|
||||
...
|
||||
giampaolo 31475 0.0 0.0 20760 3024 /dev/pts/0 Jun19 00:00 python2.4
|
||||
giampaolo 31721 0.0 2.2 773060 181896 00:04 10:30 chrome
|
||||
root 31763 0.0 0.0 0 0 00:05 00:00 kworker/0:1
|
||||
>>>
|
||||
|
||||
Further process APIs
|
||||
--------------------
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> import psutil
|
||||
>>> for proc in psutil.process_iter(['pid', 'name']):
|
||||
... print(proc.info)
|
||||
...
|
||||
{'pid': 1, 'name': 'systemd'}
|
||||
{'pid': 2, 'name': 'kthreadd'}
|
||||
{'pid': 3, 'name': 'ksoftirqd/0'}
|
||||
...
|
||||
>>>
|
||||
>>> psutil.pid_exists(3)
|
||||
True
|
||||
>>>
|
||||
>>> def on_terminate(proc):
|
||||
... print("process {} terminated".format(proc))
|
||||
...
|
||||
>>> # waits for multiple processes to terminate
|
||||
>>> gone, alive = psutil.wait_procs(procs_list, timeout=3, callback=on_terminate)
|
||||
>>>
|
||||
|
||||
Windows services
|
||||
----------------
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> list(psutil.win_service_iter())
|
||||
[<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
|
||||
<WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
|
||||
<WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
|
||||
<WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
|
||||
...]
|
||||
>>> s = psutil.win_service_get('alg')
|
||||
>>> s.as_dict()
|
||||
{'binpath': 'C:\\Windows\\System32\\alg.exe',
|
||||
'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
|
||||
'display_name': 'Application Layer Gateway Service',
|
||||
'name': 'alg',
|
||||
'pid': None,
|
||||
'start_type': 'manual',
|
||||
'status': 'stopped',
|
||||
'username': 'NT AUTHORITY\\LocalService'}
|
||||
|
||||
Projects using psutil
|
||||
=====================
|
||||
|
||||
Here's some I find particularly interesting:
|
||||
|
||||
- https://github.com/google/grr
|
||||
- https://github.com/facebook/osquery/
|
||||
- https://github.com/nicolargo/glances
|
||||
- https://github.com/Jahaja/psdash
|
||||
- https://github.com/ajenti/ajenti
|
||||
- https://github.com/home-assistant/home-assistant/
|
||||
|
||||
Portings
|
||||
========
|
||||
|
||||
- Go: https://github.com/shirou/gopsutil
|
||||
- C: https://github.com/hamon-in/cpslib
|
||||
- Rust: https://github.com/rust-psutil/rust-psutil
|
||||
- Nim: https://github.com/johnscillieri/psutil-nim
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
psutil-5.9.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
|
||||
psutil-5.9.5.dist-info/LICENSE,sha256=uJwGOzeG4o4MCjjxkx22H-015p3SopZvvs_-4PRsjRA,1548
|
||||
psutil-5.9.5.dist-info/METADATA,sha256=uDJ6Q8bZSrpEL5A4UiFwhGh-YZ49hTKX1nQ_HNGk-to,22286
|
||||
psutil-5.9.5.dist-info/RECORD,,
|
||||
psutil-5.9.5.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
||||
psutil-5.9.5.dist-info/WHEEL,sha256=6T9Pg2pD_yPHLuMTEFjb-Zm7zh3tSJ_FWsG-py1owQ4,101
|
||||
psutil-5.9.5.dist-info/top_level.txt,sha256=gCNhn57wzksDjSAISmgMJ0aiXzQulk0GJhb2-BAyYgw,7
|
||||
psutil/__init__.py,sha256=8IGKjtzyuxi_30ba7gaWHHFJBFIlsBysDKE97aGU09g,87655
|
||||
psutil/__init__.pyc,,
|
||||
psutil/_common.py,sha256=dznxb7FnWDi4L1YkEt-zthzA_U4Znlz4BoOq6xMmYyE,29181
|
||||
psutil/_common.pyc,,
|
||||
psutil/_compat.py,sha256=xinS1biWfcFStCZqhiuc_sz1HVZNLSUjIVL0lDfQa6E,15025
|
||||
psutil/_compat.pyc,,
|
||||
psutil/_psaix.py,sha256=pMRwme04xaacsLLgPO0iLVRZeNGxagDQFed_wE1peeE,18665
|
||||
psutil/_psaix.pyc,,
|
||||
psutil/_psbsd.py,sha256=ps6hnXsMwOeJTmoCrvEa-oFZxFWRA0_7tl47sR-XSHA,31769
|
||||
psutil/_psbsd.pyc,,
|
||||
psutil/_pslinux.py,sha256=ATzRCV1HNlfAUva5qiDXP73jJYOcQY4zjVz2aTfYZxo,86913
|
||||
psutil/_pslinux.pyc,,
|
||||
psutil/_psosx.py,sha256=OBj01V3f5yiNgvray-Mf9Q8A5MyqNSkysRi_AtM9hh8,16275
|
||||
psutil/_psosx.pyc,,
|
||||
psutil/_psposix.py,sha256=9_6tt24W5vZljaIZvIFC2LunfvS3nUQoEnT53rQneIU,8245
|
||||
psutil/_psposix.pyc,,
|
||||
psutil/_pssunos.py,sha256=jhfA0BKnJ0LjSc96BM_Ye5CtsO6rCcs5lKYnwTxNtTQ,25486
|
||||
psutil/_pssunos.pyc,,
|
||||
psutil/_psutil_windows.pyd,sha256=akFZ_smNe5OzS_eTk5vOgdPHILFfTJ9LsnOgPmXkgKQ,66048
|
||||
psutil/_pswindows.py,sha256=vahebTfnu3KQiwtTsXqzBMvRfQrjnlfvgxFh7Xless0,37425
|
||||
psutil/_pswindows.pyc,,
|
||||
psutil/tests/__init__.py,sha256=zuXPt7vMr47hZ2rncsCIGmVoS-JRFOhN4INBhRzioaY,59238
|
||||
psutil/tests/__init__.pyc,,
|
||||
psutil/tests/__main__.py,sha256=hhM384jjFQtDF9sTj_DXaBQCXCVLwdyjLil4UTXke8Q,293
|
||||
psutil/tests/__main__.pyc,,
|
||||
psutil/tests/runner.py,sha256=ezm1dJbuimOLEYRk_8LrAS1RF-hGT1Kkha_hb8720tY,11204
|
||||
psutil/tests/runner.pyc,,
|
||||
psutil/tests/test_aix.py,sha256=B5zO6M4JF5noyt0Tui_GzQTvBh-MjG7Rk5AFzkOmXLM,4508
|
||||
psutil/tests/test_aix.pyc,,
|
||||
psutil/tests/test_bsd.py,sha256=LUKPlXkay3nRx9T1vO1OgGjPorYhAWWH-sSeJ6MDie0,21057
|
||||
psutil/tests/test_bsd.pyc,,
|
||||
psutil/tests/test_connections.py,sha256=LUI3j17l5zVqwKW0dsBBb3URyKj-tVFzWeLTgUP86UU,20914
|
||||
psutil/tests/test_connections.pyc,,
|
||||
psutil/tests/test_contracts.py,sha256=W-9gY2RD6mcBPMytsXDLkJeD31TWsVK9Yev9ba1Lsn0,27749
|
||||
psutil/tests/test_contracts.pyc,,
|
||||
psutil/tests/test_linux.py,sha256=R5HxyLMugpuxyXQxYfQHl9Z-PP_Ag0KSSI0BAX-_Tpk,95287
|
||||
psutil/tests/test_linux.pyc,,
|
||||
psutil/tests/test_memleaks.py,sha256=f650fy6Wmi_-LmZC9QSU_PGnVlFqZwndU3TcZavkbBk,15028
|
||||
psutil/tests/test_memleaks.pyc,,
|
||||
psutil/tests/test_misc.py,sha256=YX49rKQB69SuBJ5ExZWOL_SECUONSGMnYsft3Y3WNu4,34650
|
||||
psutil/tests/test_misc.pyc,,
|
||||
psutil/tests/test_osx.py,sha256=9VkWHO7fkMxDnnw3ajN7dhpzLuChGq8tZz_s7YJ-bBQ,6587
|
||||
psutil/tests/test_osx.pyc,,
|
||||
psutil/tests/test_posix.py,sha256=ViZYO7gvy9lYx3mHxUZ3l1CSoPIWZK7_N9JPAS_2_BI,17021
|
||||
psutil/tests/test_posix.pyc,,
|
||||
psutil/tests/test_process.py,sha256=uIIK-9O-hbH8tK2br9zciShfhOw4aaUbbubozSeRb9U,63086
|
||||
psutil/tests/test_process.pyc,,
|
||||
psutil/tests/test_sunos.py,sha256=-gnzJy9mc6rwovtoXKYJw_h71FaCXgWLp85POlL1RtE,1333
|
||||
psutil/tests/test_sunos.pyc,,
|
||||
psutil/tests/test_system.py,sha256=We9JtiuVcNZoMAfqIucebUPRNCBer6gT78CZYYi74Ok,35920
|
||||
psutil/tests/test_system.pyc,,
|
||||
psutil/tests/test_testutils.py,sha256=uZneXlZmUOYnhfX2jwJ0mHJ4Her-K9LvkG8IKCRCKmA,14619
|
||||
psutil/tests/test_testutils.pyc,,
|
||||
psutil/tests/test_unicode.py,sha256=zegKp55cXbEcaiMTuzeDGehcZq9EyUMDKFamrH8c8k4,12227
|
||||
psutil/tests/test_unicode.pyc,,
|
||||
psutil/tests/test_windows.py,sha256=pOrjK-wjodiUMCGbjMDtTpnoxqgY42ND1LHMEhpLpNM,35167
|
||||
psutil/tests/test_windows.pyc,,
|
|
@ -0,0 +1,5 @@
|
|||
Wheel-Version: 1.0
|
||||
Generator: bdist_wheel (0.37.1)
|
||||
Root-Is-Purelib: false
|
||||
Tag: cp27-cp27m-win_amd64
|
||||
|
|
@ -0,0 +1 @@
|
|||
psutil
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,936 @@
|
|||
# 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
|
||||
from __future__ import print_function
|
||||
|
||||
import collections
|
||||
import contextlib
|
||||
import errno
|
||||
import functools
|
||||
import os
|
||||
import socket
|
||||
import stat
|
||||
import sys
|
||||
import threading
|
||||
import warnings
|
||||
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
|
||||
PSUTIL_DEBUG = bool(os.getenv('PSUTIL_DEBUG'))
|
||||
_DEFAULT = object()
|
||||
|
||||
__all__ = [
|
||||
# OS constants
|
||||
'FREEBSD', 'BSD', 'LINUX', 'NETBSD', 'OPENBSD', 'MACOS', 'OSX', 'POSIX',
|
||||
'SUNOS', 'WINDOWS',
|
||||
# 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',
|
||||
# other constants
|
||||
'ENCODING', 'ENCODING_ERRS', 'AF_INET6',
|
||||
# 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",
|
||||
'open_text', 'open_binary', 'cat', 'bcat',
|
||||
'bytes2human', 'conn_to_ntuple', 'debug',
|
||||
# shell utils
|
||||
'hilite', 'term_supports_colors', 'print_color',
|
||||
]
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- 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", "midnightbsd"))
|
||||
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',
|
||||
'maxfile', 'maxpath'])
|
||||
# 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', 'flags'])
|
||||
# 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]),
|
||||
})
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- Exceptions
|
||||
# =====================================================================
|
||||
|
||||
|
||||
class Error(Exception):
|
||||
"""Base exception class. All other psutil exceptions inherit
|
||||
from this one.
|
||||
"""
|
||||
__module__ = 'psutil'
|
||||
|
||||
def _infodict(self, attrs):
|
||||
info = collections.OrderedDict()
|
||||
for name in attrs:
|
||||
value = getattr(self, name, None)
|
||||
if value:
|
||||
info[name] = value
|
||||
elif name == "pid" and value == 0:
|
||||
info[name] = value
|
||||
return info
|
||||
|
||||
def __str__(self):
|
||||
# invoked on `raise Error`
|
||||
info = self._infodict(("pid", "ppid", "name"))
|
||||
if info:
|
||||
details = "(%s)" % ", ".join(
|
||||
["%s=%r" % (k, v) for k, v in info.items()])
|
||||
else:
|
||||
details = None
|
||||
return " ".join([x for x in (getattr(self, "msg", ""), details) if x])
|
||||
|
||||
def __repr__(self):
|
||||
# invoked on `repr(Error)`
|
||||
info = self._infodict(("pid", "ppid", "name", "seconds", "msg"))
|
||||
details = ", ".join(["%s=%r" % (k, v) for k, v in info.items()])
|
||||
return "psutil.%s(%s)" % (self.__class__.__name__, details)
|
||||
|
||||
|
||||
class NoSuchProcess(Error):
|
||||
"""Exception raised when a process with a certain PID doesn't
|
||||
or no longer exists.
|
||||
"""
|
||||
__module__ = 'psutil'
|
||||
|
||||
def __init__(self, pid, name=None, msg=None):
|
||||
Error.__init__(self)
|
||||
self.pid = pid
|
||||
self.name = name
|
||||
self.msg = msg or "process no longer exists"
|
||||
|
||||
|
||||
class ZombieProcess(NoSuchProcess):
|
||||
"""Exception raised when querying a zombie process. This is
|
||||
raised on macOS, BSD and Solaris only, and not always: depending
|
||||
on the query the OS may be able to succeed anyway.
|
||||
On Linux all zombie processes are querable (hence this is never
|
||||
raised). Windows doesn't have zombie processes.
|
||||
"""
|
||||
__module__ = 'psutil'
|
||||
|
||||
def __init__(self, pid, name=None, ppid=None, msg=None):
|
||||
NoSuchProcess.__init__(self, pid, name, msg)
|
||||
self.ppid = ppid
|
||||
self.msg = msg or "PID still exists but it's a zombie"
|
||||
|
||||
|
||||
class AccessDenied(Error):
|
||||
"""Exception raised when permission to perform an action is denied."""
|
||||
__module__ = 'psutil'
|
||||
|
||||
def __init__(self, pid=None, name=None, msg=None):
|
||||
Error.__init__(self)
|
||||
self.pid = pid
|
||||
self.name = name
|
||||
self.msg = msg or ""
|
||||
|
||||
|
||||
class TimeoutExpired(Error):
|
||||
"""Raised on Process.wait(timeout) if timeout expires and process
|
||||
is still alive.
|
||||
"""
|
||||
__module__ = 'psutil'
|
||||
|
||||
def __init__(self, seconds, pid=None, name=None):
|
||||
Error.__init__(self)
|
||||
self.seconds = seconds
|
||||
self.pid = pid
|
||||
self.name = name
|
||||
self.msg = "timeout after %s seconds" % seconds
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- utils
|
||||
# ===================================================================
|
||||
|
||||
|
||||
# This should be in _compat.py rather than here, but does not work well
|
||||
# with setup.py importing this module via a sys.path trick.
|
||||
if PY3:
|
||||
if isinstance(__builtins__, dict): # cpython
|
||||
exec_ = __builtins__["exec"]
|
||||
else: # pypy
|
||||
exec_ = getattr(__builtins__, "exec") # noqa
|
||||
|
||||
exec_("""def raise_from(value, from_value):
|
||||
try:
|
||||
raise value from from_value
|
||||
finally:
|
||||
value = None
|
||||
""")
|
||||
else:
|
||||
def raise_from(value, from_value):
|
||||
raise value
|
||||
|
||||
|
||||
def usage_percent(used, total, round_=None):
|
||||
"""Calculate percentage usage of 'used' against 'total'."""
|
||||
try:
|
||||
ret = (float(used) / total) * 100
|
||||
except ZeroDivisionError:
|
||||
return 0.0
|
||||
else:
|
||||
if round_ is not None:
|
||||
ret = round(ret, round_)
|
||||
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()
|
||||
>>>
|
||||
|
||||
It supports:
|
||||
- functions
|
||||
- classes (acts as a @singleton)
|
||||
- staticmethods
|
||||
- classmethods
|
||||
|
||||
It does NOT support:
|
||||
- methods
|
||||
"""
|
||||
@functools.wraps(fun)
|
||||
def wrapper(*args, **kwargs):
|
||||
key = (args, frozenset(sorted(kwargs.items())))
|
||||
try:
|
||||
return cache[key]
|
||||
except KeyError:
|
||||
try:
|
||||
ret = cache[key] = fun(*args, **kwargs)
|
||||
except Exception as err:
|
||||
raise raise_from(err, None)
|
||||
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(self)
|
||||
>>> foo()
|
||||
1
|
||||
>>> foo()
|
||||
>>> foo()
|
||||
>>>
|
||||
"""
|
||||
@functools.wraps(fun)
|
||||
def wrapper(self):
|
||||
try:
|
||||
# case 1: we previously entered oneshot() ctx
|
||||
ret = self._cache[fun]
|
||||
except AttributeError:
|
||||
# case 2: we never entered oneshot() ctx
|
||||
try:
|
||||
return fun(self)
|
||||
except Exception as err:
|
||||
raise raise_from(err, None)
|
||||
except KeyError:
|
||||
# case 3: we entered oneshot() ctx but there's no cache
|
||||
# for this entry yet
|
||||
try:
|
||||
ret = fun(self)
|
||||
except Exception as err:
|
||||
raise raise_from(err, None)
|
||||
try:
|
||||
self._cache[fun] = ret
|
||||
except AttributeError:
|
||||
# multi-threading race condition, see:
|
||||
# https://github.com/giampaolo/psutil/issues/1948
|
||||
pass
|
||||
return ret
|
||||
|
||||
def cache_activate(proc):
|
||||
"""Activate cache. Expects a Process instance. Cache will be
|
||||
stored as a "_cache" instance attribute."""
|
||||
proc._cache = {}
|
||||
|
||||
def cache_deactivate(proc):
|
||||
"""Deactivate and clear cache."""
|
||||
try:
|
||||
del proc._cache
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
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:
|
||||
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.SocketKind(num)
|
||||
except ValueError:
|
||||
return num
|
||||
|
||||
|
||||
def conn_to_ntuple(fd, fam, type_, laddr, raddr, status, status_map, pid=None):
|
||||
"""Convert a raw connection tuple to a proper ntuple."""
|
||||
if fam in (socket.AF_INET, AF_INET6):
|
||||
if laddr:
|
||||
laddr = addr(*laddr)
|
||||
if raddr:
|
||||
raddr = addr(*raddr)
|
||||
if type_ == socket.SOCK_STREAM and fam in (AF_INET, AF_INET6):
|
||||
status = status_map.get(status, CONN_NONE)
|
||||
else:
|
||||
status = CONN_NONE # ignore whatever C returned to us
|
||||
fam = sockfam_to_enum(fam)
|
||||
type_ = socktype_to_enum(type_)
|
||||
if pid is None:
|
||||
return pconn(fd, fam, type_, laddr, raddr, status)
|
||||
else:
|
||||
return sconn(fd, fam, type_, laddr, raddr, status, pid)
|
||||
|
||||
|
||||
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=DeprecationWarning, 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] = collections.defaultdict(int)
|
||||
self.reminder_keys[name] = collections.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
|
||||
|
||||
|
||||
# The read buffer size for open() builtin. This (also) dictates how
|
||||
# much data we read(2) when iterating over file lines as in:
|
||||
# >>> with open(file) as f:
|
||||
# ... for line in f:
|
||||
# ... ...
|
||||
# Default per-line buffer size for binary files is 1K. For text files
|
||||
# is 8K. We use a bigger buffer (32K) in order to have more consistent
|
||||
# results when reading /proc pseudo files on Linux, see:
|
||||
# https://github.com/giampaolo/psutil/issues/2050
|
||||
# On Python 2 this also speeds up the reading of big files:
|
||||
# (namely /proc/{pid}/smaps and /proc/net/*):
|
||||
# https://github.com/giampaolo/psutil/issues/708
|
||||
FILE_READ_BUFFER_SIZE = 32 * 1024
|
||||
|
||||
|
||||
def open_binary(fname):
|
||||
return open(fname, "rb", buffering=FILE_READ_BUFFER_SIZE)
|
||||
|
||||
|
||||
def open_text(fname):
|
||||
"""On Python 3 opens a file in text mode by using fs encoding and
|
||||
a proper en/decoding errors handler.
|
||||
On Python 2 this is just an alias for open(name, 'rt').
|
||||
"""
|
||||
if not PY3:
|
||||
return open(fname, "rt", buffering=FILE_READ_BUFFER_SIZE)
|
||||
|
||||
# See:
|
||||
# https://github.com/giampaolo/psutil/issues/675
|
||||
# https://github.com/giampaolo/psutil/pull/733
|
||||
fobj = open(fname, "rt", buffering=FILE_READ_BUFFER_SIZE,
|
||||
encoding=ENCODING, errors=ENCODING_ERRS)
|
||||
try:
|
||||
# Dictates per-line read(2) buffer size. Defaults is 8k. See:
|
||||
# https://github.com/giampaolo/psutil/issues/2050#issuecomment-1013387546
|
||||
fobj._CHUNK_SIZE = FILE_READ_BUFFER_SIZE
|
||||
except AttributeError:
|
||||
pass
|
||||
except Exception:
|
||||
fobj.close()
|
||||
raise
|
||||
|
||||
return fobj
|
||||
|
||||
|
||||
def cat(fname, fallback=_DEFAULT, _open=open_text):
|
||||
"""Read entire file content and return it as a string. File is
|
||||
opened in text mode. If specified, `fallback` is the value
|
||||
returned in case of error, either if the file does not exist or
|
||||
it can't be read().
|
||||
"""
|
||||
if fallback is _DEFAULT:
|
||||
with _open(fname) as f:
|
||||
return f.read()
|
||||
else:
|
||||
try:
|
||||
with _open(fname) as f:
|
||||
return f.read()
|
||||
except (IOError, OSError):
|
||||
return fallback
|
||||
|
||||
|
||||
def bcat(fname, fallback=_DEFAULT):
|
||||
"""Same as above but opens file in binary mode."""
|
||||
return cat(fname, fallback=fallback, _open=open_binary)
|
||||
|
||||
|
||||
def bytes2human(n, format="%(value).1f%(symbol)s"):
|
||||
"""Used by various scripts. See:
|
||||
http://goo.gl/zeJZl
|
||||
|
||||
>>> bytes2human(10000)
|
||||
'9.8K'
|
||||
>>> bytes2human(100001221)
|
||||
'95.4M'
|
||||
"""
|
||||
symbols = ('B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
|
||||
prefix = {}
|
||||
for i, s in enumerate(symbols[1:]):
|
||||
prefix[s] = 1 << (i + 1) * 10
|
||||
for symbol in reversed(symbols[1:]):
|
||||
if n >= prefix[symbol]:
|
||||
value = float(n) / prefix[symbol]
|
||||
return format % locals()
|
||||
return format % dict(symbol=symbols[0], value=n)
|
||||
|
||||
|
||||
def get_procfs_path():
|
||||
"""Return updated psutil.PROCFS_PATH constant."""
|
||||
return sys.modules['psutil'].PROCFS_PATH
|
||||
|
||||
|
||||
if PY3:
|
||||
def decode(s):
|
||||
return s.decode(encoding=ENCODING, errors=ENCODING_ERRS)
|
||||
else:
|
||||
def decode(s):
|
||||
return s
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- shell utils
|
||||
# =====================================================================
|
||||
|
||||
|
||||
@memoize
|
||||
def term_supports_colors(file=sys.stdout): # pragma: no cover
|
||||
if os.name == 'nt':
|
||||
return True
|
||||
try:
|
||||
import curses
|
||||
assert file.isatty()
|
||||
curses.setupterm()
|
||||
assert curses.tigetnum("colors") > 0
|
||||
except Exception:
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
def hilite(s, color=None, bold=False): # pragma: no cover
|
||||
"""Return an highlighted version of 'string'."""
|
||||
if not term_supports_colors():
|
||||
return s
|
||||
attr = []
|
||||
colors = dict(green='32', red='91', brown='33', yellow='93', blue='34',
|
||||
violet='35', lightblue='36', grey='37', darkgrey='30')
|
||||
colors[None] = '29'
|
||||
try:
|
||||
color = colors[color]
|
||||
except KeyError:
|
||||
raise ValueError("invalid color %r; choose between %s" % (
|
||||
list(colors.keys())))
|
||||
attr.append(color)
|
||||
if bold:
|
||||
attr.append('1')
|
||||
return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), s)
|
||||
|
||||
|
||||
def print_color(
|
||||
s, color=None, bold=False, file=sys.stdout): # pragma: no cover
|
||||
"""Print a colorized version of string."""
|
||||
if not term_supports_colors():
|
||||
print(s, file=file) # NOQA
|
||||
elif POSIX:
|
||||
print(hilite(s, color, bold), file=file) # NOQA
|
||||
else:
|
||||
import ctypes
|
||||
|
||||
DEFAULT_COLOR = 7
|
||||
GetStdHandle = ctypes.windll.Kernel32.GetStdHandle
|
||||
SetConsoleTextAttribute = \
|
||||
ctypes.windll.Kernel32.SetConsoleTextAttribute
|
||||
|
||||
colors = dict(green=2, red=4, brown=6, yellow=6)
|
||||
colors[None] = DEFAULT_COLOR
|
||||
try:
|
||||
color = colors[color]
|
||||
except KeyError:
|
||||
raise ValueError("invalid color %r; choose between %r" % (
|
||||
color, list(colors.keys())))
|
||||
if bold and color <= 7:
|
||||
color += 8
|
||||
|
||||
handle_id = -12 if file is sys.stderr else -11
|
||||
GetStdHandle.restype = ctypes.c_ulong
|
||||
handle = GetStdHandle(handle_id)
|
||||
SetConsoleTextAttribute(handle, color)
|
||||
try:
|
||||
print(s, file=file) # NOQA
|
||||
finally:
|
||||
SetConsoleTextAttribute(handle, DEFAULT_COLOR)
|
||||
|
||||
|
||||
def debug(msg):
|
||||
"""If PSUTIL_DEBUG env var is set, print a debug message to stderr."""
|
||||
if PSUTIL_DEBUG:
|
||||
import inspect
|
||||
fname, lineno, _, lines, index = inspect.getframeinfo(
|
||||
inspect.currentframe().f_back)
|
||||
if isinstance(msg, Exception):
|
||||
if isinstance(msg, (OSError, IOError, EnvironmentError)):
|
||||
# ...because str(exc) may contain info about the file name
|
||||
msg = "ignoring %s" % msg
|
||||
else:
|
||||
msg = "ignoring %r" % msg
|
||||
print("psutil-debug [%s:%s]> %s" % (fname, lineno, msg), # NOQA
|
||||
file=sys.stderr)
|
|
@ -0,0 +1,450 @@
|
|||
# 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.
|
||||
|
||||
"""Module which provides compatibility with older Python versions.
|
||||
This is more future-compatible rather than the opposite (prefer latest
|
||||
Python 3 way of doing things).
|
||||
"""
|
||||
|
||||
import collections
|
||||
import contextlib
|
||||
import errno
|
||||
import functools
|
||||
import os
|
||||
import sys
|
||||
import types
|
||||
|
||||
|
||||
__all__ = [
|
||||
# constants
|
||||
"PY3",
|
||||
# builtins
|
||||
"long", "range", "super", "unicode", "basestring",
|
||||
# literals
|
||||
"u", "b",
|
||||
# collections module
|
||||
"lru_cache",
|
||||
# shutil module
|
||||
"which", "get_terminal_size",
|
||||
# contextlib module
|
||||
"redirect_stderr",
|
||||
# python 3 exceptions
|
||||
"FileNotFoundError", "PermissionError", "ProcessLookupError",
|
||||
"InterruptedError", "ChildProcessError", "FileExistsError"]
|
||||
|
||||
|
||||
PY3 = sys.version_info[0] == 3
|
||||
_SENTINEL = object()
|
||||
|
||||
if PY3:
|
||||
long = int
|
||||
xrange = range
|
||||
unicode = str
|
||||
basestring = str
|
||||
range = range
|
||||
|
||||
def u(s):
|
||||
return s
|
||||
|
||||
def b(s):
|
||||
return s.encode("latin-1")
|
||||
else:
|
||||
long = long
|
||||
range = xrange
|
||||
unicode = unicode
|
||||
basestring = basestring
|
||||
|
||||
def u(s):
|
||||
return unicode(s, "unicode_escape")
|
||||
|
||||
def b(s):
|
||||
return s
|
||||
|
||||
|
||||
# --- builtins
|
||||
|
||||
|
||||
# Python 3 super().
|
||||
# Taken from "future" package.
|
||||
# Credit: Ryan Kelly
|
||||
if PY3:
|
||||
super = super
|
||||
else:
|
||||
_builtin_super = super
|
||||
|
||||
def super(type_=_SENTINEL, type_or_obj=_SENTINEL, framedepth=1):
|
||||
"""Like Python 3 builtin super(). If called without any arguments
|
||||
it attempts to infer them at runtime.
|
||||
"""
|
||||
if type_ is _SENTINEL:
|
||||
f = sys._getframe(framedepth)
|
||||
try:
|
||||
# Get the function's first positional argument.
|
||||
type_or_obj = f.f_locals[f.f_code.co_varnames[0]]
|
||||
except (IndexError, KeyError):
|
||||
raise RuntimeError('super() used in a function with no args')
|
||||
try:
|
||||
# Get the MRO so we can crawl it.
|
||||
mro = type_or_obj.__mro__
|
||||
except (AttributeError, RuntimeError):
|
||||
try:
|
||||
mro = type_or_obj.__class__.__mro__
|
||||
except AttributeError:
|
||||
raise RuntimeError('super() used in a non-newstyle class')
|
||||
for type_ in mro:
|
||||
# Find the class that owns the currently-executing method.
|
||||
for meth in type_.__dict__.values():
|
||||
# Drill down through any wrappers to the underlying func.
|
||||
# This handles e.g. classmethod() and staticmethod().
|
||||
try:
|
||||
while not isinstance(meth, types.FunctionType):
|
||||
if isinstance(meth, property):
|
||||
# Calling __get__ on the property will invoke
|
||||
# user code which might throw exceptions or
|
||||
# have side effects
|
||||
meth = meth.fget
|
||||
else:
|
||||
try:
|
||||
meth = meth.__func__
|
||||
except AttributeError:
|
||||
meth = meth.__get__(type_or_obj, type_)
|
||||
except (AttributeError, TypeError):
|
||||
continue
|
||||
if meth.func_code is f.f_code:
|
||||
break # found
|
||||
else:
|
||||
# Not found. Move onto the next class in MRO.
|
||||
continue
|
||||
break # found
|
||||
else:
|
||||
raise RuntimeError('super() called outside a method')
|
||||
|
||||
# Dispatch to builtin super().
|
||||
if type_or_obj is not _SENTINEL:
|
||||
return _builtin_super(type_, type_or_obj)
|
||||
return _builtin_super(type_)
|
||||
|
||||
|
||||
# --- exceptions
|
||||
|
||||
|
||||
if PY3:
|
||||
FileNotFoundError = FileNotFoundError # NOQA
|
||||
PermissionError = PermissionError # NOQA
|
||||
ProcessLookupError = ProcessLookupError # NOQA
|
||||
InterruptedError = InterruptedError # NOQA
|
||||
ChildProcessError = ChildProcessError # NOQA
|
||||
FileExistsError = FileExistsError # NOQA
|
||||
else:
|
||||
# https://github.com/PythonCharmers/python-future/blob/exceptions/
|
||||
# src/future/types/exceptions/pep3151.py
|
||||
import platform
|
||||
|
||||
def _instance_checking_exception(base_exception=Exception):
|
||||
def wrapped(instance_checker):
|
||||
class TemporaryClass(base_exception):
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
if len(args) == 1 and isinstance(args[0], TemporaryClass):
|
||||
unwrap_me = args[0]
|
||||
for attr in dir(unwrap_me):
|
||||
if not attr.startswith('__'):
|
||||
setattr(self, attr, getattr(unwrap_me, attr))
|
||||
else:
|
||||
super(TemporaryClass, self).__init__(*args, **kwargs)
|
||||
|
||||
class __metaclass__(type):
|
||||
def __instancecheck__(cls, inst):
|
||||
return instance_checker(inst)
|
||||
|
||||
def __subclasscheck__(cls, classinfo):
|
||||
value = sys.exc_info()[1]
|
||||
return isinstance(value, cls)
|
||||
|
||||
TemporaryClass.__name__ = instance_checker.__name__
|
||||
TemporaryClass.__doc__ = instance_checker.__doc__
|
||||
return TemporaryClass
|
||||
|
||||
return wrapped
|
||||
|
||||
@_instance_checking_exception(EnvironmentError)
|
||||
def FileNotFoundError(inst):
|
||||
return getattr(inst, 'errno', _SENTINEL) == errno.ENOENT
|
||||
|
||||
@_instance_checking_exception(EnvironmentError)
|
||||
def ProcessLookupError(inst):
|
||||
return getattr(inst, 'errno', _SENTINEL) == errno.ESRCH
|
||||
|
||||
@_instance_checking_exception(EnvironmentError)
|
||||
def PermissionError(inst):
|
||||
return getattr(inst, 'errno', _SENTINEL) in (
|
||||
errno.EACCES, errno.EPERM)
|
||||
|
||||
@_instance_checking_exception(EnvironmentError)
|
||||
def InterruptedError(inst):
|
||||
return getattr(inst, 'errno', _SENTINEL) == errno.EINTR
|
||||
|
||||
@_instance_checking_exception(EnvironmentError)
|
||||
def ChildProcessError(inst):
|
||||
return getattr(inst, 'errno', _SENTINEL) == errno.ECHILD
|
||||
|
||||
@_instance_checking_exception(EnvironmentError)
|
||||
def FileExistsError(inst):
|
||||
return getattr(inst, 'errno', _SENTINEL) == errno.EEXIST
|
||||
|
||||
if platform.python_implementation() != "CPython":
|
||||
try:
|
||||
raise OSError(errno.EEXIST, "perm")
|
||||
except FileExistsError:
|
||||
pass
|
||||
except OSError:
|
||||
raise RuntimeError(
|
||||
"broken or incompatible Python implementation, see: "
|
||||
"https://github.com/giampaolo/psutil/issues/1659")
|
||||
|
||||
|
||||
# --- stdlib additions
|
||||
|
||||
|
||||
# py 3.2 functools.lru_cache
|
||||
# Taken from: http://code.activestate.com/recipes/578078
|
||||
# Credit: Raymond Hettinger
|
||||
try:
|
||||
from functools import lru_cache
|
||||
except ImportError:
|
||||
try:
|
||||
from threading import RLock
|
||||
except ImportError:
|
||||
from dummy_threading import RLock
|
||||
|
||||
_CacheInfo = collections.namedtuple(
|
||||
"CacheInfo", ["hits", "misses", "maxsize", "currsize"])
|
||||
|
||||
class _HashedSeq(list):
|
||||
__slots__ = 'hashvalue'
|
||||
|
||||
def __init__(self, tup, hash=hash):
|
||||
self[:] = tup
|
||||
self.hashvalue = hash(tup)
|
||||
|
||||
def __hash__(self):
|
||||
return self.hashvalue
|
||||
|
||||
def _make_key(args, kwds, typed,
|
||||
kwd_mark=(_SENTINEL, ),
|
||||
fasttypes=set((int, str, frozenset, type(None))), # noqa
|
||||
sorted=sorted, tuple=tuple, type=type, len=len):
|
||||
key = args
|
||||
if kwds:
|
||||
sorted_items = sorted(kwds.items())
|
||||
key += kwd_mark
|
||||
for item in sorted_items:
|
||||
key += item
|
||||
if typed:
|
||||
key += tuple(type(v) for v in args)
|
||||
if kwds:
|
||||
key += tuple(type(v) for k, v in sorted_items)
|
||||
elif len(key) == 1 and type(key[0]) in fasttypes:
|
||||
return key[0]
|
||||
return _HashedSeq(key)
|
||||
|
||||
def lru_cache(maxsize=100, typed=False):
|
||||
"""Least-recently-used cache decorator, see:
|
||||
http://docs.python.org/3/library/functools.html#functools.lru_cache
|
||||
"""
|
||||
def decorating_function(user_function):
|
||||
cache = {}
|
||||
stats = [0, 0]
|
||||
HITS, MISSES = 0, 1
|
||||
make_key = _make_key
|
||||
cache_get = cache.get
|
||||
_len = len
|
||||
lock = RLock()
|
||||
root = []
|
||||
root[:] = [root, root, None, None]
|
||||
nonlocal_root = [root]
|
||||
PREV, NEXT, KEY, RESULT = 0, 1, 2, 3
|
||||
if maxsize == 0:
|
||||
def wrapper(*args, **kwds):
|
||||
result = user_function(*args, **kwds)
|
||||
stats[MISSES] += 1
|
||||
return result
|
||||
elif maxsize is None:
|
||||
def wrapper(*args, **kwds):
|
||||
key = make_key(args, kwds, typed)
|
||||
result = cache_get(key, root)
|
||||
if result is not root:
|
||||
stats[HITS] += 1
|
||||
return result
|
||||
result = user_function(*args, **kwds)
|
||||
cache[key] = result
|
||||
stats[MISSES] += 1
|
||||
return result
|
||||
else:
|
||||
def wrapper(*args, **kwds):
|
||||
if kwds or typed:
|
||||
key = make_key(args, kwds, typed)
|
||||
else:
|
||||
key = args
|
||||
lock.acquire()
|
||||
try:
|
||||
link = cache_get(key)
|
||||
if link is not None:
|
||||
root, = nonlocal_root
|
||||
link_prev, link_next, key, result = link
|
||||
link_prev[NEXT] = link_next
|
||||
link_next[PREV] = link_prev
|
||||
last = root[PREV]
|
||||
last[NEXT] = root[PREV] = link
|
||||
link[PREV] = last
|
||||
link[NEXT] = root
|
||||
stats[HITS] += 1
|
||||
return result
|
||||
finally:
|
||||
lock.release()
|
||||
result = user_function(*args, **kwds)
|
||||
lock.acquire()
|
||||
try:
|
||||
root, = nonlocal_root
|
||||
if key in cache:
|
||||
pass
|
||||
elif _len(cache) >= maxsize:
|
||||
oldroot = root
|
||||
oldroot[KEY] = key
|
||||
oldroot[RESULT] = result
|
||||
root = nonlocal_root[0] = oldroot[NEXT]
|
||||
oldkey = root[KEY]
|
||||
root[KEY] = root[RESULT] = None
|
||||
del cache[oldkey]
|
||||
cache[key] = oldroot
|
||||
else:
|
||||
last = root[PREV]
|
||||
link = [last, root, key, result]
|
||||
last[NEXT] = root[PREV] = cache[key] = link
|
||||
stats[MISSES] += 1
|
||||
finally:
|
||||
lock.release()
|
||||
return result
|
||||
|
||||
def cache_info():
|
||||
"""Report cache statistics"""
|
||||
lock.acquire()
|
||||
try:
|
||||
return _CacheInfo(stats[HITS], stats[MISSES], maxsize,
|
||||
len(cache))
|
||||
finally:
|
||||
lock.release()
|
||||
|
||||
def cache_clear():
|
||||
"""Clear the cache and cache statistics"""
|
||||
lock.acquire()
|
||||
try:
|
||||
cache.clear()
|
||||
root = nonlocal_root[0]
|
||||
root[:] = [root, root, None, None]
|
||||
stats[:] = [0, 0]
|
||||
finally:
|
||||
lock.release()
|
||||
|
||||
wrapper.__wrapped__ = user_function
|
||||
wrapper.cache_info = cache_info
|
||||
wrapper.cache_clear = cache_clear
|
||||
return functools.update_wrapper(wrapper, user_function)
|
||||
|
||||
return decorating_function
|
||||
|
||||
|
||||
# python 3.3
|
||||
try:
|
||||
from shutil import which
|
||||
except ImportError:
|
||||
def which(cmd, mode=os.F_OK | os.X_OK, path=None):
|
||||
"""Given a command, mode, and a PATH string, return the path which
|
||||
conforms to the given mode on the PATH, or None if there is no such
|
||||
file.
|
||||
|
||||
`mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
|
||||
of os.environ.get("PATH"), or can be overridden with a custom search
|
||||
path.
|
||||
"""
|
||||
def _access_check(fn, mode):
|
||||
return (os.path.exists(fn) and os.access(fn, mode) and
|
||||
not os.path.isdir(fn))
|
||||
|
||||
if os.path.dirname(cmd):
|
||||
if _access_check(cmd, mode):
|
||||
return cmd
|
||||
return None
|
||||
|
||||
if path is None:
|
||||
path = os.environ.get("PATH", os.defpath)
|
||||
if not path:
|
||||
return None
|
||||
path = path.split(os.pathsep)
|
||||
|
||||
if sys.platform == "win32":
|
||||
if os.curdir not in path:
|
||||
path.insert(0, os.curdir)
|
||||
|
||||
pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
|
||||
if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
|
||||
files = [cmd]
|
||||
else:
|
||||
files = [cmd + ext for ext in pathext]
|
||||
else:
|
||||
files = [cmd]
|
||||
|
||||
seen = set()
|
||||
for dir in path:
|
||||
normdir = os.path.normcase(dir)
|
||||
if normdir not in seen:
|
||||
seen.add(normdir)
|
||||
for thefile in files:
|
||||
name = os.path.join(dir, thefile)
|
||||
if _access_check(name, mode):
|
||||
return name
|
||||
return None
|
||||
|
||||
|
||||
# python 3.3
|
||||
try:
|
||||
from shutil import get_terminal_size
|
||||
except ImportError:
|
||||
def get_terminal_size(fallback=(80, 24)):
|
||||
try:
|
||||
import fcntl
|
||||
import struct
|
||||
import termios
|
||||
except ImportError:
|
||||
return fallback
|
||||
else:
|
||||
try:
|
||||
# This should work on Linux.
|
||||
res = struct.unpack(
|
||||
'hh', fcntl.ioctl(1, termios.TIOCGWINSZ, '1234'))
|
||||
return (res[1], res[0])
|
||||
except Exception:
|
||||
return fallback
|
||||
|
||||
|
||||
# python 3.3
|
||||
try:
|
||||
from subprocess import TimeoutExpired as SubprocessTimeoutExpired
|
||||
except ImportError:
|
||||
class SubprocessTimeoutExpired(Exception):
|
||||
pass
|
||||
|
||||
|
||||
# python 3.5
|
||||
try:
|
||||
from contextlib import redirect_stderr
|
||||
except ImportError:
|
||||
@contextlib.contextmanager
|
||||
def redirect_stderr(new_target):
|
||||
original = sys.stderr
|
||||
try:
|
||||
sys.stderr = new_target
|
||||
yield new_target
|
||||
finally:
|
||||
sys.stderr = original
|
|
@ -0,0 +1,555 @@
|
|||
# Copyright (c) 2009, Giampaolo Rodola'
|
||||
# Copyright (c) 2017, Arnon Yaari
|
||||
# All rights reserved.
|
||||
# Use of this source code is governed by a BSD-style license that can be
|
||||
# found in the LICENSE file.
|
||||
|
||||
"""AIX platform implementation."""
|
||||
|
||||
import functools
|
||||
import glob
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from collections import namedtuple
|
||||
|
||||
from . import _common
|
||||
from . import _psposix
|
||||
from . import _psutil_aix as cext
|
||||
from . import _psutil_posix as cext_posix
|
||||
from ._common import NIC_DUPLEX_FULL
|
||||
from ._common import NIC_DUPLEX_HALF
|
||||
from ._common import NIC_DUPLEX_UNKNOWN
|
||||
from ._common import AccessDenied
|
||||
from ._common import NoSuchProcess
|
||||
from ._common import ZombieProcess
|
||||
from ._common import conn_to_ntuple
|
||||
from ._common import get_procfs_path
|
||||
from ._common import memoize_when_activated
|
||||
from ._common import usage_percent
|
||||
from ._compat import PY3
|
||||
from ._compat import FileNotFoundError
|
||||
from ._compat import PermissionError
|
||||
from ._compat import ProcessLookupError
|
||||
|
||||
|
||||
__extra__all__ = ["PROCFS_PATH"]
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- globals
|
||||
# =====================================================================
|
||||
|
||||
|
||||
HAS_THREADS = hasattr(cext, "proc_threads")
|
||||
HAS_NET_IO_COUNTERS = hasattr(cext, "net_io_counters")
|
||||
HAS_PROC_IO_COUNTERS = hasattr(cext, "proc_io_counters")
|
||||
|
||||
PAGE_SIZE = cext_posix.getpagesize()
|
||||
AF_LINK = cext_posix.AF_LINK
|
||||
|
||||
PROC_STATUSES = {
|
||||
cext.SIDL: _common.STATUS_IDLE,
|
||||
cext.SZOMB: _common.STATUS_ZOMBIE,
|
||||
cext.SACTIVE: _common.STATUS_RUNNING,
|
||||
cext.SSWAP: _common.STATUS_RUNNING, # TODO what status is this?
|
||||
cext.SSTOP: _common.STATUS_STOPPED,
|
||||
}
|
||||
|
||||
TCP_STATUSES = {
|
||||
cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
|
||||
cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
|
||||
cext.TCPS_SYN_RCVD: _common.CONN_SYN_RECV,
|
||||
cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
|
||||
cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
|
||||
cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
|
||||
cext.TCPS_CLOSED: _common.CONN_CLOSE,
|
||||
cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
|
||||
cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
|
||||
cext.TCPS_LISTEN: _common.CONN_LISTEN,
|
||||
cext.TCPS_CLOSING: _common.CONN_CLOSING,
|
||||
cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
|
||||
}
|
||||
|
||||
proc_info_map = dict(
|
||||
ppid=0,
|
||||
rss=1,
|
||||
vms=2,
|
||||
create_time=3,
|
||||
nice=4,
|
||||
num_threads=5,
|
||||
status=6,
|
||||
ttynr=7)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- named tuples
|
||||
# =====================================================================
|
||||
|
||||
|
||||
# psutil.Process.memory_info()
|
||||
pmem = namedtuple('pmem', ['rss', 'vms'])
|
||||
# psutil.Process.memory_full_info()
|
||||
pfullmem = pmem
|
||||
# psutil.Process.cpu_times()
|
||||
scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'iowait'])
|
||||
# psutil.virtual_memory()
|
||||
svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free'])
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- memory
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def virtual_memory():
|
||||
total, avail, free, pinned, inuse = cext.virtual_mem()
|
||||
percent = usage_percent((total - avail), total, round_=1)
|
||||
return svmem(total, avail, percent, inuse, free)
|
||||
|
||||
|
||||
def swap_memory():
|
||||
"""Swap system memory as a (total, used, free, sin, sout) tuple."""
|
||||
total, free, sin, sout = cext.swap_mem()
|
||||
used = total - free
|
||||
percent = usage_percent(used, total, round_=1)
|
||||
return _common.sswap(total, used, free, percent, sin, sout)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- CPU
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def cpu_times():
|
||||
"""Return system-wide CPU times as a named tuple"""
|
||||
ret = cext.per_cpu_times()
|
||||
return scputimes(*[sum(x) for x in zip(*ret)])
|
||||
|
||||
|
||||
def per_cpu_times():
|
||||
"""Return system per-CPU times as a list of named tuples"""
|
||||
ret = cext.per_cpu_times()
|
||||
return [scputimes(*x) for x in ret]
|
||||
|
||||
|
||||
def cpu_count_logical():
|
||||
"""Return the number of logical CPUs in the system."""
|
||||
try:
|
||||
return os.sysconf("SC_NPROCESSORS_ONLN")
|
||||
except ValueError:
|
||||
# mimic os.cpu_count() behavior
|
||||
return None
|
||||
|
||||
|
||||
def cpu_count_cores():
|
||||
cmd = "lsdev -Cc processor"
|
||||
p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE)
|
||||
stdout, stderr = p.communicate()
|
||||
if PY3:
|
||||
stdout, stderr = [x.decode(sys.stdout.encoding)
|
||||
for x in (stdout, stderr)]
|
||||
if p.returncode != 0:
|
||||
raise RuntimeError("%r command error\n%s" % (cmd, stderr))
|
||||
processors = stdout.strip().splitlines()
|
||||
return len(processors) or None
|
||||
|
||||
|
||||
def cpu_stats():
|
||||
"""Return various CPU stats as a named tuple."""
|
||||
ctx_switches, interrupts, soft_interrupts, syscalls = cext.cpu_stats()
|
||||
return _common.scpustats(
|
||||
ctx_switches, interrupts, soft_interrupts, syscalls)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- disks
|
||||
# =====================================================================
|
||||
|
||||
|
||||
disk_io_counters = cext.disk_io_counters
|
||||
disk_usage = _psposix.disk_usage
|
||||
|
||||
|
||||
def disk_partitions(all=False):
|
||||
"""Return system disk partitions."""
|
||||
# TODO - the filtering logic should be better checked so that
|
||||
# it tries to reflect 'df' as much as possible
|
||||
retlist = []
|
||||
partitions = cext.disk_partitions()
|
||||
for partition in partitions:
|
||||
device, mountpoint, fstype, opts = partition
|
||||
if device == 'none':
|
||||
device = ''
|
||||
if not all:
|
||||
# Differently from, say, Linux, we don't have a list of
|
||||
# common fs types so the best we can do, AFAIK, is to
|
||||
# filter by filesystem having a total size > 0.
|
||||
if not disk_usage(mountpoint).total:
|
||||
continue
|
||||
maxfile = maxpath = None # set later
|
||||
ntuple = _common.sdiskpart(device, mountpoint, fstype, opts,
|
||||
maxfile, maxpath)
|
||||
retlist.append(ntuple)
|
||||
return retlist
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- network
|
||||
# =====================================================================
|
||||
|
||||
|
||||
net_if_addrs = cext_posix.net_if_addrs
|
||||
|
||||
if HAS_NET_IO_COUNTERS:
|
||||
net_io_counters = cext.net_io_counters
|
||||
|
||||
|
||||
def net_connections(kind, _pid=-1):
|
||||
"""Return socket connections. If pid == -1 return system-wide
|
||||
connections (as opposed to connections opened by one process only).
|
||||
"""
|
||||
cmap = _common.conn_tmap
|
||||
if kind not in cmap:
|
||||
raise ValueError("invalid %r kind argument; choose between %s"
|
||||
% (kind, ', '.join([repr(x) for x in cmap])))
|
||||
families, types = _common.conn_tmap[kind]
|
||||
rawlist = cext.net_connections(_pid)
|
||||
ret = []
|
||||
for item in rawlist:
|
||||
fd, fam, type_, laddr, raddr, status, pid = item
|
||||
if fam not in families:
|
||||
continue
|
||||
if type_ not in types:
|
||||
continue
|
||||
nt = conn_to_ntuple(fd, fam, type_, laddr, raddr, status,
|
||||
TCP_STATUSES, pid=pid if _pid == -1 else None)
|
||||
ret.append(nt)
|
||||
return ret
|
||||
|
||||
|
||||
def net_if_stats():
|
||||
"""Get NIC stats (isup, duplex, speed, mtu)."""
|
||||
duplex_map = {"Full": NIC_DUPLEX_FULL,
|
||||
"Half": NIC_DUPLEX_HALF}
|
||||
names = set([x[0] for x in net_if_addrs()])
|
||||
ret = {}
|
||||
for name in names:
|
||||
mtu = cext_posix.net_if_mtu(name)
|
||||
flags = cext_posix.net_if_flags(name)
|
||||
|
||||
# try to get speed and duplex
|
||||
# TODO: rewrite this in C (entstat forks, so use truss -f to follow.
|
||||
# looks like it is using an undocumented ioctl?)
|
||||
duplex = ""
|
||||
speed = 0
|
||||
p = subprocess.Popen(["/usr/bin/entstat", "-d", name],
|
||||
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
stdout, stderr = p.communicate()
|
||||
if PY3:
|
||||
stdout, stderr = [x.decode(sys.stdout.encoding)
|
||||
for x in (stdout, stderr)]
|
||||
if p.returncode == 0:
|
||||
re_result = re.search(
|
||||
r"Running: (\d+) Mbps.*?(\w+) Duplex", stdout)
|
||||
if re_result is not None:
|
||||
speed = int(re_result.group(1))
|
||||
duplex = re_result.group(2)
|
||||
|
||||
output_flags = ','.join(flags)
|
||||
isup = 'running' in flags
|
||||
duplex = duplex_map.get(duplex, NIC_DUPLEX_UNKNOWN)
|
||||
ret[name] = _common.snicstats(isup, duplex, speed, mtu, output_flags)
|
||||
return ret
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- other system functions
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def boot_time():
|
||||
"""The system boot time expressed in seconds since the epoch."""
|
||||
return cext.boot_time()
|
||||
|
||||
|
||||
def users():
|
||||
"""Return currently connected users as a list of namedtuples."""
|
||||
retlist = []
|
||||
rawlist = cext.users()
|
||||
localhost = (':0.0', ':0')
|
||||
for item in rawlist:
|
||||
user, tty, hostname, tstamp, user_process, pid = item
|
||||
# note: the underlying C function includes entries about
|
||||
# system boot, run level and others. We might want
|
||||
# to use them in the future.
|
||||
if not user_process:
|
||||
continue
|
||||
if hostname in localhost:
|
||||
hostname = 'localhost'
|
||||
nt = _common.suser(user, tty, hostname, tstamp, pid)
|
||||
retlist.append(nt)
|
||||
return retlist
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- processes
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def pids():
|
||||
"""Returns a list of PIDs currently running on the system."""
|
||||
return [int(x) for x in os.listdir(get_procfs_path()) if x.isdigit()]
|
||||
|
||||
|
||||
def pid_exists(pid):
|
||||
"""Check for the existence of a unix pid."""
|
||||
return os.path.exists(os.path.join(get_procfs_path(), str(pid), "psinfo"))
|
||||
|
||||
|
||||
def wrap_exceptions(fun):
|
||||
"""Call callable into a try/except clause and translate ENOENT,
|
||||
EACCES and EPERM in NoSuchProcess or AccessDenied exceptions.
|
||||
"""
|
||||
@functools.wraps(fun)
|
||||
def wrapper(self, *args, **kwargs):
|
||||
try:
|
||||
return fun(self, *args, **kwargs)
|
||||
except (FileNotFoundError, ProcessLookupError):
|
||||
# ENOENT (no such file or directory) gets raised on open().
|
||||
# ESRCH (no such process) can get raised on read() if
|
||||
# process is gone in meantime.
|
||||
if not pid_exists(self.pid):
|
||||
raise NoSuchProcess(self.pid, self._name)
|
||||
else:
|
||||
raise ZombieProcess(self.pid, self._name, self._ppid)
|
||||
except PermissionError:
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
return wrapper
|
||||
|
||||
|
||||
class Process(object):
|
||||
"""Wrapper class around underlying C implementation."""
|
||||
|
||||
__slots__ = ["pid", "_name", "_ppid", "_procfs_path", "_cache"]
|
||||
|
||||
def __init__(self, pid):
|
||||
self.pid = pid
|
||||
self._name = None
|
||||
self._ppid = None
|
||||
self._procfs_path = get_procfs_path()
|
||||
|
||||
def oneshot_enter(self):
|
||||
self._proc_basic_info.cache_activate(self)
|
||||
self._proc_cred.cache_activate(self)
|
||||
|
||||
def oneshot_exit(self):
|
||||
self._proc_basic_info.cache_deactivate(self)
|
||||
self._proc_cred.cache_deactivate(self)
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def _proc_basic_info(self):
|
||||
return cext.proc_basic_info(self.pid, self._procfs_path)
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def _proc_cred(self):
|
||||
return cext.proc_cred(self.pid, self._procfs_path)
|
||||
|
||||
@wrap_exceptions
|
||||
def name(self):
|
||||
if self.pid == 0:
|
||||
return "swapper"
|
||||
# note: max 16 characters
|
||||
return cext.proc_name(self.pid, self._procfs_path).rstrip("\x00")
|
||||
|
||||
@wrap_exceptions
|
||||
def exe(self):
|
||||
# there is no way to get executable path in AIX other than to guess,
|
||||
# and guessing is more complex than what's in the wrapping class
|
||||
cmdline = self.cmdline()
|
||||
if not cmdline:
|
||||
return ''
|
||||
exe = cmdline[0]
|
||||
if os.path.sep in exe:
|
||||
# relative or absolute path
|
||||
if not os.path.isabs(exe):
|
||||
# if cwd has changed, we're out of luck - this may be wrong!
|
||||
exe = os.path.abspath(os.path.join(self.cwd(), exe))
|
||||
if (os.path.isabs(exe) and
|
||||
os.path.isfile(exe) and
|
||||
os.access(exe, os.X_OK)):
|
||||
return exe
|
||||
# not found, move to search in PATH using basename only
|
||||
exe = os.path.basename(exe)
|
||||
# search for exe name PATH
|
||||
for path in os.environ["PATH"].split(":"):
|
||||
possible_exe = os.path.abspath(os.path.join(path, exe))
|
||||
if (os.path.isfile(possible_exe) and
|
||||
os.access(possible_exe, os.X_OK)):
|
||||
return possible_exe
|
||||
return ''
|
||||
|
||||
@wrap_exceptions
|
||||
def cmdline(self):
|
||||
return cext.proc_args(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def environ(self):
|
||||
return cext.proc_environ(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def create_time(self):
|
||||
return self._proc_basic_info()[proc_info_map['create_time']]
|
||||
|
||||
@wrap_exceptions
|
||||
def num_threads(self):
|
||||
return self._proc_basic_info()[proc_info_map['num_threads']]
|
||||
|
||||
if HAS_THREADS:
|
||||
@wrap_exceptions
|
||||
def threads(self):
|
||||
rawlist = cext.proc_threads(self.pid)
|
||||
retlist = []
|
||||
for thread_id, utime, stime in rawlist:
|
||||
ntuple = _common.pthread(thread_id, utime, stime)
|
||||
retlist.append(ntuple)
|
||||
# The underlying C implementation retrieves all OS threads
|
||||
# and filters them by PID. At this point we can't tell whether
|
||||
# an empty list means there were no connections for process or
|
||||
# process is no longer active so we force NSP in case the PID
|
||||
# is no longer there.
|
||||
if not retlist:
|
||||
# will raise NSP if process is gone
|
||||
os.stat('%s/%s' % (self._procfs_path, self.pid))
|
||||
return retlist
|
||||
|
||||
@wrap_exceptions
|
||||
def connections(self, kind='inet'):
|
||||
ret = net_connections(kind, _pid=self.pid)
|
||||
# The underlying C implementation retrieves all OS connections
|
||||
# and filters them by PID. At this point we can't tell whether
|
||||
# an empty list means there were no connections for process or
|
||||
# process is no longer active so we force NSP in case the PID
|
||||
# is no longer there.
|
||||
if not ret:
|
||||
# will raise NSP if process is gone
|
||||
os.stat('%s/%s' % (self._procfs_path, self.pid))
|
||||
return ret
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_get(self):
|
||||
return cext_posix.getpriority(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_set(self, value):
|
||||
return cext_posix.setpriority(self.pid, value)
|
||||
|
||||
@wrap_exceptions
|
||||
def ppid(self):
|
||||
self._ppid = self._proc_basic_info()[proc_info_map['ppid']]
|
||||
return self._ppid
|
||||
|
||||
@wrap_exceptions
|
||||
def uids(self):
|
||||
real, effective, saved, _, _, _ = self._proc_cred()
|
||||
return _common.puids(real, effective, saved)
|
||||
|
||||
@wrap_exceptions
|
||||
def gids(self):
|
||||
_, _, _, real, effective, saved = self._proc_cred()
|
||||
return _common.puids(real, effective, saved)
|
||||
|
||||
@wrap_exceptions
|
||||
def cpu_times(self):
|
||||
t = cext.proc_cpu_times(self.pid, self._procfs_path)
|
||||
return _common.pcputimes(*t)
|
||||
|
||||
@wrap_exceptions
|
||||
def terminal(self):
|
||||
ttydev = self._proc_basic_info()[proc_info_map['ttynr']]
|
||||
# convert from 64-bit dev_t to 32-bit dev_t and then map the device
|
||||
ttydev = (((ttydev & 0x0000FFFF00000000) >> 16) | (ttydev & 0xFFFF))
|
||||
# try to match rdev of /dev/pts/* files ttydev
|
||||
for dev in glob.glob("/dev/**/*"):
|
||||
if os.stat(dev).st_rdev == ttydev:
|
||||
return dev
|
||||
return None
|
||||
|
||||
@wrap_exceptions
|
||||
def cwd(self):
|
||||
procfs_path = self._procfs_path
|
||||
try:
|
||||
result = os.readlink("%s/%s/cwd" % (procfs_path, self.pid))
|
||||
return result.rstrip('/')
|
||||
except FileNotFoundError:
|
||||
os.stat("%s/%s" % (procfs_path, self.pid)) # raise NSP or AD
|
||||
return ""
|
||||
|
||||
@wrap_exceptions
|
||||
def memory_info(self):
|
||||
ret = self._proc_basic_info()
|
||||
rss = ret[proc_info_map['rss']] * 1024
|
||||
vms = ret[proc_info_map['vms']] * 1024
|
||||
return pmem(rss, vms)
|
||||
|
||||
memory_full_info = memory_info
|
||||
|
||||
@wrap_exceptions
|
||||
def status(self):
|
||||
code = self._proc_basic_info()[proc_info_map['status']]
|
||||
# XXX is '?' legit? (we're not supposed to return it anyway)
|
||||
return PROC_STATUSES.get(code, '?')
|
||||
|
||||
def open_files(self):
|
||||
# TODO rewrite without using procfiles (stat /proc/pid/fd/* and then
|
||||
# find matching name of the inode)
|
||||
p = subprocess.Popen(["/usr/bin/procfiles", "-n", str(self.pid)],
|
||||
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
stdout, stderr = p.communicate()
|
||||
if PY3:
|
||||
stdout, stderr = [x.decode(sys.stdout.encoding)
|
||||
for x in (stdout, stderr)]
|
||||
if "no such process" in stderr.lower():
|
||||
raise NoSuchProcess(self.pid, self._name)
|
||||
procfiles = re.findall(r"(\d+): S_IFREG.*\s*.*name:(.*)\n", stdout)
|
||||
retlist = []
|
||||
for fd, path in procfiles:
|
||||
path = path.strip()
|
||||
if path.startswith("//"):
|
||||
path = path[1:]
|
||||
if path.lower() == "cannot be retrieved":
|
||||
continue
|
||||
retlist.append(_common.popenfile(path, int(fd)))
|
||||
return retlist
|
||||
|
||||
@wrap_exceptions
|
||||
def num_fds(self):
|
||||
if self.pid == 0: # no /proc/0/fd
|
||||
return 0
|
||||
return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid)))
|
||||
|
||||
@wrap_exceptions
|
||||
def num_ctx_switches(self):
|
||||
return _common.pctxsw(
|
||||
*cext.proc_num_ctx_switches(self.pid))
|
||||
|
||||
@wrap_exceptions
|
||||
def wait(self, timeout=None):
|
||||
return _psposix.wait_pid(self.pid, timeout, self._name)
|
||||
|
||||
if HAS_PROC_IO_COUNTERS:
|
||||
@wrap_exceptions
|
||||
def io_counters(self):
|
||||
try:
|
||||
rc, wc, rb, wb = cext.proc_io_counters(self.pid)
|
||||
except OSError:
|
||||
# if process is terminated, proc_io_counters returns OSError
|
||||
# instead of NSP
|
||||
if not pid_exists(self.pid):
|
||||
raise NoSuchProcess(self.pid, self._name)
|
||||
raise
|
||||
return _common.pio(rc, wc, rb, wb)
|
|
@ -0,0 +1,927 @@
|
|||
# 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.
|
||||
|
||||
"""FreeBSD, OpenBSD and NetBSD platforms implementation."""
|
||||
|
||||
import contextlib
|
||||
import errno
|
||||
import functools
|
||||
import os
|
||||
import xml.etree.ElementTree as ET
|
||||
from collections import defaultdict
|
||||
from collections import namedtuple
|
||||
|
||||
from . import _common
|
||||
from . import _psposix
|
||||
from . import _psutil_bsd as cext
|
||||
from . import _psutil_posix as cext_posix
|
||||
from ._common import FREEBSD
|
||||
from ._common import NETBSD
|
||||
from ._common import OPENBSD
|
||||
from ._common import AccessDenied
|
||||
from ._common import NoSuchProcess
|
||||
from ._common import ZombieProcess
|
||||
from ._common import conn_tmap
|
||||
from ._common import conn_to_ntuple
|
||||
from ._common import memoize
|
||||
from ._common import memoize_when_activated
|
||||
from ._common import usage_percent
|
||||
from ._compat import FileNotFoundError
|
||||
from ._compat import PermissionError
|
||||
from ._compat import ProcessLookupError
|
||||
from ._compat import which
|
||||
|
||||
|
||||
__extra__all__ = []
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- globals
|
||||
# =====================================================================
|
||||
|
||||
|
||||
if FREEBSD:
|
||||
PROC_STATUSES = {
|
||||
cext.SIDL: _common.STATUS_IDLE,
|
||||
cext.SRUN: _common.STATUS_RUNNING,
|
||||
cext.SSLEEP: _common.STATUS_SLEEPING,
|
||||
cext.SSTOP: _common.STATUS_STOPPED,
|
||||
cext.SZOMB: _common.STATUS_ZOMBIE,
|
||||
cext.SWAIT: _common.STATUS_WAITING,
|
||||
cext.SLOCK: _common.STATUS_LOCKED,
|
||||
}
|
||||
elif OPENBSD:
|
||||
PROC_STATUSES = {
|
||||
cext.SIDL: _common.STATUS_IDLE,
|
||||
cext.SSLEEP: _common.STATUS_SLEEPING,
|
||||
cext.SSTOP: _common.STATUS_STOPPED,
|
||||
# According to /usr/include/sys/proc.h SZOMB is unused.
|
||||
# test_zombie_process() shows that SDEAD is the right
|
||||
# equivalent. Also it appears there's no equivalent of
|
||||
# psutil.STATUS_DEAD. SDEAD really means STATUS_ZOMBIE.
|
||||
# cext.SZOMB: _common.STATUS_ZOMBIE,
|
||||
cext.SDEAD: _common.STATUS_ZOMBIE,
|
||||
cext.SZOMB: _common.STATUS_ZOMBIE,
|
||||
# From http://www.eecs.harvard.edu/~margo/cs161/videos/proc.h.txt
|
||||
# OpenBSD has SRUN and SONPROC: SRUN indicates that a process
|
||||
# is runnable but *not* yet running, i.e. is on a run queue.
|
||||
# SONPROC indicates that the process is actually executing on
|
||||
# a CPU, i.e. it is no longer on a run queue.
|
||||
# As such we'll map SRUN to STATUS_WAKING and SONPROC to
|
||||
# STATUS_RUNNING
|
||||
cext.SRUN: _common.STATUS_WAKING,
|
||||
cext.SONPROC: _common.STATUS_RUNNING,
|
||||
}
|
||||
elif NETBSD:
|
||||
PROC_STATUSES = {
|
||||
cext.SIDL: _common.STATUS_IDLE,
|
||||
cext.SSLEEP: _common.STATUS_SLEEPING,
|
||||
cext.SSTOP: _common.STATUS_STOPPED,
|
||||
cext.SZOMB: _common.STATUS_ZOMBIE,
|
||||
cext.SRUN: _common.STATUS_WAKING,
|
||||
cext.SONPROC: _common.STATUS_RUNNING,
|
||||
}
|
||||
|
||||
TCP_STATUSES = {
|
||||
cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
|
||||
cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
|
||||
cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV,
|
||||
cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
|
||||
cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
|
||||
cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
|
||||
cext.TCPS_CLOSED: _common.CONN_CLOSE,
|
||||
cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
|
||||
cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
|
||||
cext.TCPS_LISTEN: _common.CONN_LISTEN,
|
||||
cext.TCPS_CLOSING: _common.CONN_CLOSING,
|
||||
cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
|
||||
}
|
||||
|
||||
PAGESIZE = cext_posix.getpagesize()
|
||||
AF_LINK = cext_posix.AF_LINK
|
||||
|
||||
HAS_PER_CPU_TIMES = hasattr(cext, "per_cpu_times")
|
||||
HAS_PROC_NUM_THREADS = hasattr(cext, "proc_num_threads")
|
||||
HAS_PROC_OPEN_FILES = hasattr(cext, 'proc_open_files')
|
||||
HAS_PROC_NUM_FDS = hasattr(cext, 'proc_num_fds')
|
||||
|
||||
kinfo_proc_map = dict(
|
||||
ppid=0,
|
||||
status=1,
|
||||
real_uid=2,
|
||||
effective_uid=3,
|
||||
saved_uid=4,
|
||||
real_gid=5,
|
||||
effective_gid=6,
|
||||
saved_gid=7,
|
||||
ttynr=8,
|
||||
create_time=9,
|
||||
ctx_switches_vol=10,
|
||||
ctx_switches_unvol=11,
|
||||
read_io_count=12,
|
||||
write_io_count=13,
|
||||
user_time=14,
|
||||
sys_time=15,
|
||||
ch_user_time=16,
|
||||
ch_sys_time=17,
|
||||
rss=18,
|
||||
vms=19,
|
||||
memtext=20,
|
||||
memdata=21,
|
||||
memstack=22,
|
||||
cpunum=23,
|
||||
name=24,
|
||||
)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- named tuples
|
||||
# =====================================================================
|
||||
|
||||
|
||||
# psutil.virtual_memory()
|
||||
svmem = namedtuple(
|
||||
'svmem', ['total', 'available', 'percent', 'used', 'free',
|
||||
'active', 'inactive', 'buffers', 'cached', 'shared', 'wired'])
|
||||
# psutil.cpu_times()
|
||||
scputimes = namedtuple(
|
||||
'scputimes', ['user', 'nice', 'system', 'idle', 'irq'])
|
||||
# psutil.Process.memory_info()
|
||||
pmem = namedtuple('pmem', ['rss', 'vms', 'text', 'data', 'stack'])
|
||||
# psutil.Process.memory_full_info()
|
||||
pfullmem = pmem
|
||||
# psutil.Process.cpu_times()
|
||||
pcputimes = namedtuple('pcputimes',
|
||||
['user', 'system', 'children_user', 'children_system'])
|
||||
# psutil.Process.memory_maps(grouped=True)
|
||||
pmmap_grouped = namedtuple(
|
||||
'pmmap_grouped', 'path rss, private, ref_count, shadow_count')
|
||||
# psutil.Process.memory_maps(grouped=False)
|
||||
pmmap_ext = namedtuple(
|
||||
'pmmap_ext', 'addr, perms path rss, private, ref_count, shadow_count')
|
||||
# psutil.disk_io_counters()
|
||||
if FREEBSD:
|
||||
sdiskio = namedtuple('sdiskio', ['read_count', 'write_count',
|
||||
'read_bytes', 'write_bytes',
|
||||
'read_time', 'write_time',
|
||||
'busy_time'])
|
||||
else:
|
||||
sdiskio = namedtuple('sdiskio', ['read_count', 'write_count',
|
||||
'read_bytes', 'write_bytes'])
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- memory
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def virtual_memory():
|
||||
mem = cext.virtual_mem()
|
||||
if NETBSD:
|
||||
total, free, active, inactive, wired, cached = mem
|
||||
# On NetBSD buffers and shared mem is determined via /proc.
|
||||
# The C ext set them to 0.
|
||||
with open('/proc/meminfo', 'rb') as f:
|
||||
for line in f:
|
||||
if line.startswith(b'Buffers:'):
|
||||
buffers = int(line.split()[1]) * 1024
|
||||
elif line.startswith(b'MemShared:'):
|
||||
shared = int(line.split()[1]) * 1024
|
||||
# Before avail was calculated as (inactive + cached + free),
|
||||
# same as zabbix, but it turned out it could exceed total (see
|
||||
# #2233), so zabbix seems to be wrong. Htop calculates it
|
||||
# differently, and the used value seem more realistic, so let's
|
||||
# match htop.
|
||||
# https://github.com/htop-dev/htop/blob/e7f447b/netbsd/NetBSDProcessList.c#L162 # noqa
|
||||
# https://github.com/zabbix/zabbix/blob/af5e0f8/src/libs/zbxsysinfo/netbsd/memory.c#L135 # noqa
|
||||
used = active + wired
|
||||
avail = total - used
|
||||
else:
|
||||
total, free, active, inactive, wired, cached, buffers, shared = mem
|
||||
# matches freebsd-memory CLI:
|
||||
# * https://people.freebsd.org/~rse/dist/freebsd-memory
|
||||
# * https://www.cyberciti.biz/files/scripts/freebsd-memory.pl.txt
|
||||
# matches zabbix:
|
||||
# * https://github.com/zabbix/zabbix/blob/af5e0f8/src/libs/zbxsysinfo/freebsd/memory.c#L143 # noqa
|
||||
avail = inactive + cached + free
|
||||
used = active + wired + cached
|
||||
|
||||
percent = usage_percent((total - avail), total, round_=1)
|
||||
return svmem(total, avail, percent, used, free,
|
||||
active, inactive, buffers, cached, shared, wired)
|
||||
|
||||
|
||||
def swap_memory():
|
||||
"""System swap memory as (total, used, free, sin, sout) namedtuple."""
|
||||
total, used, free, sin, sout = cext.swap_mem()
|
||||
percent = usage_percent(used, total, round_=1)
|
||||
return _common.sswap(total, used, free, percent, sin, sout)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- CPU
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def cpu_times():
|
||||
"""Return system per-CPU times as a namedtuple"""
|
||||
user, nice, system, idle, irq = cext.cpu_times()
|
||||
return scputimes(user, nice, system, idle, irq)
|
||||
|
||||
|
||||
if HAS_PER_CPU_TIMES:
|
||||
def per_cpu_times():
|
||||
"""Return system CPU times as a namedtuple"""
|
||||
ret = []
|
||||
for cpu_t in cext.per_cpu_times():
|
||||
user, nice, system, idle, irq = cpu_t
|
||||
item = scputimes(user, nice, system, idle, irq)
|
||||
ret.append(item)
|
||||
return ret
|
||||
else:
|
||||
# XXX
|
||||
# Ok, this is very dirty.
|
||||
# On FreeBSD < 8 we cannot gather per-cpu information, see:
|
||||
# https://github.com/giampaolo/psutil/issues/226
|
||||
# If num cpus > 1, on first call we return single cpu times to avoid a
|
||||
# crash at psutil import time.
|
||||
# Next calls will fail with NotImplementedError
|
||||
def per_cpu_times():
|
||||
"""Return system CPU times as a namedtuple"""
|
||||
if cpu_count_logical() == 1:
|
||||
return [cpu_times()]
|
||||
if per_cpu_times.__called__:
|
||||
raise NotImplementedError("supported only starting from FreeBSD 8")
|
||||
per_cpu_times.__called__ = True
|
||||
return [cpu_times()]
|
||||
|
||||
per_cpu_times.__called__ = False
|
||||
|
||||
|
||||
def cpu_count_logical():
|
||||
"""Return the number of logical CPUs in the system."""
|
||||
return cext.cpu_count_logical()
|
||||
|
||||
|
||||
if OPENBSD or NETBSD:
|
||||
def cpu_count_cores():
|
||||
# OpenBSD and NetBSD do not implement this.
|
||||
return 1 if cpu_count_logical() == 1 else None
|
||||
else:
|
||||
def cpu_count_cores():
|
||||
"""Return the number of CPU cores in the system."""
|
||||
# From the C module we'll get an XML string similar to this:
|
||||
# http://manpages.ubuntu.com/manpages/precise/man4/smp.4freebsd.html
|
||||
# We may get None in case "sysctl kern.sched.topology_spec"
|
||||
# is not supported on this BSD version, in which case we'll mimic
|
||||
# os.cpu_count() and return None.
|
||||
ret = None
|
||||
s = cext.cpu_topology()
|
||||
if s is not None:
|
||||
# get rid of padding chars appended at the end of the string
|
||||
index = s.rfind("</groups>")
|
||||
if index != -1:
|
||||
s = s[:index + 9]
|
||||
root = ET.fromstring(s)
|
||||
try:
|
||||
ret = len(root.findall('group/children/group/cpu')) or None
|
||||
finally:
|
||||
# needed otherwise it will memleak
|
||||
root.clear()
|
||||
if not ret:
|
||||
# If logical CPUs == 1 it's obvious we' have only 1 core.
|
||||
if cpu_count_logical() == 1:
|
||||
return 1
|
||||
return ret
|
||||
|
||||
|
||||
def cpu_stats():
|
||||
"""Return various CPU stats as a named tuple."""
|
||||
if FREEBSD:
|
||||
# Note: the C ext is returning some metrics we are not exposing:
|
||||
# traps.
|
||||
ctxsw, intrs, soft_intrs, syscalls, traps = cext.cpu_stats()
|
||||
elif NETBSD:
|
||||
# XXX
|
||||
# Note about intrs: the C extension returns 0. intrs
|
||||
# can be determined via /proc/stat; it has the same value as
|
||||
# soft_intrs thought so the kernel is faking it (?).
|
||||
#
|
||||
# Note about syscalls: the C extension always sets it to 0 (?).
|
||||
#
|
||||
# Note: the C ext is returning some metrics we are not exposing:
|
||||
# traps, faults and forks.
|
||||
ctxsw, intrs, soft_intrs, syscalls, traps, faults, forks = \
|
||||
cext.cpu_stats()
|
||||
with open('/proc/stat', 'rb') as f:
|
||||
for line in f:
|
||||
if line.startswith(b'intr'):
|
||||
intrs = int(line.split()[1])
|
||||
elif OPENBSD:
|
||||
# Note: the C ext is returning some metrics we are not exposing:
|
||||
# traps, faults and forks.
|
||||
ctxsw, intrs, soft_intrs, syscalls, traps, faults, forks = \
|
||||
cext.cpu_stats()
|
||||
return _common.scpustats(ctxsw, intrs, soft_intrs, syscalls)
|
||||
|
||||
|
||||
if FREEBSD:
|
||||
def cpu_freq():
|
||||
"""Return frequency metrics for CPUs. As of Dec 2018 only
|
||||
CPU 0 appears to be supported by FreeBSD and all other cores
|
||||
match the frequency of CPU 0.
|
||||
"""
|
||||
ret = []
|
||||
num_cpus = cpu_count_logical()
|
||||
for cpu in range(num_cpus):
|
||||
try:
|
||||
current, available_freq = cext.cpu_freq(cpu)
|
||||
except NotImplementedError:
|
||||
continue
|
||||
if available_freq:
|
||||
try:
|
||||
min_freq = int(available_freq.split(" ")[-1].split("/")[0])
|
||||
except (IndexError, ValueError):
|
||||
min_freq = None
|
||||
try:
|
||||
max_freq = int(available_freq.split(" ")[0].split("/")[0])
|
||||
except (IndexError, ValueError):
|
||||
max_freq = None
|
||||
ret.append(_common.scpufreq(current, min_freq, max_freq))
|
||||
return ret
|
||||
elif OPENBSD:
|
||||
def cpu_freq():
|
||||
curr = float(cext.cpu_freq())
|
||||
return [_common.scpufreq(curr, 0.0, 0.0)]
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- disks
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def disk_partitions(all=False):
|
||||
"""Return mounted disk partitions as a list of namedtuples.
|
||||
'all' argument is ignored, see:
|
||||
https://github.com/giampaolo/psutil/issues/906
|
||||
"""
|
||||
retlist = []
|
||||
partitions = cext.disk_partitions()
|
||||
for partition in partitions:
|
||||
device, mountpoint, fstype, opts = partition
|
||||
maxfile = maxpath = None # set later
|
||||
ntuple = _common.sdiskpart(device, mountpoint, fstype, opts,
|
||||
maxfile, maxpath)
|
||||
retlist.append(ntuple)
|
||||
return retlist
|
||||
|
||||
|
||||
disk_usage = _psposix.disk_usage
|
||||
disk_io_counters = cext.disk_io_counters
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- network
|
||||
# =====================================================================
|
||||
|
||||
|
||||
net_io_counters = cext.net_io_counters
|
||||
net_if_addrs = cext_posix.net_if_addrs
|
||||
|
||||
|
||||
def net_if_stats():
|
||||
"""Get NIC stats (isup, duplex, speed, mtu)."""
|
||||
names = net_io_counters().keys()
|
||||
ret = {}
|
||||
for name in names:
|
||||
try:
|
||||
mtu = cext_posix.net_if_mtu(name)
|
||||
flags = cext_posix.net_if_flags(name)
|
||||
duplex, speed = cext_posix.net_if_duplex_speed(name)
|
||||
except OSError as err:
|
||||
# https://github.com/giampaolo/psutil/issues/1279
|
||||
if err.errno != errno.ENODEV:
|
||||
raise
|
||||
else:
|
||||
if hasattr(_common, 'NicDuplex'):
|
||||
duplex = _common.NicDuplex(duplex)
|
||||
output_flags = ','.join(flags)
|
||||
isup = 'running' in flags
|
||||
ret[name] = _common.snicstats(isup, duplex, speed, mtu,
|
||||
output_flags)
|
||||
return ret
|
||||
|
||||
|
||||
def net_connections(kind):
|
||||
"""System-wide network connections."""
|
||||
if kind not in _common.conn_tmap:
|
||||
raise ValueError("invalid %r kind argument; choose between %s"
|
||||
% (kind, ', '.join([repr(x) for x in conn_tmap])))
|
||||
families, types = conn_tmap[kind]
|
||||
ret = set()
|
||||
|
||||
if OPENBSD:
|
||||
rawlist = cext.net_connections(-1, families, types)
|
||||
elif NETBSD:
|
||||
rawlist = cext.net_connections(-1)
|
||||
else: # FreeBSD
|
||||
rawlist = cext.net_connections()
|
||||
|
||||
for item in rawlist:
|
||||
fd, fam, type, laddr, raddr, status, pid = item
|
||||
if NETBSD or FREEBSD:
|
||||
# OpenBSD implements filtering in C
|
||||
if (fam not in families) or (type not in types):
|
||||
continue
|
||||
nt = conn_to_ntuple(fd, fam, type, laddr, raddr,
|
||||
status, TCP_STATUSES, pid)
|
||||
ret.add(nt)
|
||||
return list(ret)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- sensors
|
||||
# =====================================================================
|
||||
|
||||
|
||||
if FREEBSD:
|
||||
|
||||
def sensors_battery():
|
||||
"""Return battery info."""
|
||||
try:
|
||||
percent, minsleft, power_plugged = cext.sensors_battery()
|
||||
except NotImplementedError:
|
||||
# See: https://github.com/giampaolo/psutil/issues/1074
|
||||
return None
|
||||
power_plugged = power_plugged == 1
|
||||
if power_plugged:
|
||||
secsleft = _common.POWER_TIME_UNLIMITED
|
||||
elif minsleft == -1:
|
||||
secsleft = _common.POWER_TIME_UNKNOWN
|
||||
else:
|
||||
secsleft = minsleft * 60
|
||||
return _common.sbattery(percent, secsleft, power_plugged)
|
||||
|
||||
def sensors_temperatures():
|
||||
"""Return CPU cores temperatures if available, else an empty dict."""
|
||||
ret = defaultdict(list)
|
||||
num_cpus = cpu_count_logical()
|
||||
for cpu in range(num_cpus):
|
||||
try:
|
||||
current, high = cext.sensors_cpu_temperature(cpu)
|
||||
if high <= 0:
|
||||
high = None
|
||||
name = "Core %s" % cpu
|
||||
ret["coretemp"].append(
|
||||
_common.shwtemp(name, current, high, high))
|
||||
except NotImplementedError:
|
||||
pass
|
||||
|
||||
return ret
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- other system functions
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def boot_time():
|
||||
"""The system boot time expressed in seconds since the epoch."""
|
||||
return cext.boot_time()
|
||||
|
||||
|
||||
def users():
|
||||
"""Return currently connected users as a list of namedtuples."""
|
||||
retlist = []
|
||||
rawlist = cext.users()
|
||||
for item in rawlist:
|
||||
user, tty, hostname, tstamp, pid = item
|
||||
if pid == -1:
|
||||
assert OPENBSD
|
||||
pid = None
|
||||
if tty == '~':
|
||||
continue # reboot or shutdown
|
||||
nt = _common.suser(user, tty or None, hostname, tstamp, pid)
|
||||
retlist.append(nt)
|
||||
return retlist
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- processes
|
||||
# =====================================================================
|
||||
|
||||
|
||||
@memoize
|
||||
def _pid_0_exists():
|
||||
try:
|
||||
Process(0).name()
|
||||
except NoSuchProcess:
|
||||
return False
|
||||
except AccessDenied:
|
||||
return True
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
def pids():
|
||||
"""Returns a list of PIDs currently running on the system."""
|
||||
ret = cext.pids()
|
||||
if OPENBSD and (0 not in ret) and _pid_0_exists():
|
||||
# On OpenBSD the kernel does not return PID 0 (neither does
|
||||
# ps) but it's actually querable (Process(0) will succeed).
|
||||
ret.insert(0, 0)
|
||||
return ret
|
||||
|
||||
|
||||
if OPENBSD or NETBSD:
|
||||
def pid_exists(pid):
|
||||
"""Return True if pid exists."""
|
||||
exists = _psposix.pid_exists(pid)
|
||||
if not exists:
|
||||
# We do this because _psposix.pid_exists() lies in case of
|
||||
# zombie processes.
|
||||
return pid in pids()
|
||||
else:
|
||||
return True
|
||||
else:
|
||||
pid_exists = _psposix.pid_exists
|
||||
|
||||
|
||||
def is_zombie(pid):
|
||||
try:
|
||||
st = cext.proc_oneshot_info(pid)[kinfo_proc_map['status']]
|
||||
return PROC_STATUSES.get(st) == _common.STATUS_ZOMBIE
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def wrap_exceptions(fun):
|
||||
"""Decorator which translates bare OSError exceptions into
|
||||
NoSuchProcess and AccessDenied.
|
||||
"""
|
||||
@functools.wraps(fun)
|
||||
def wrapper(self, *args, **kwargs):
|
||||
try:
|
||||
return fun(self, *args, **kwargs)
|
||||
except ProcessLookupError:
|
||||
if is_zombie(self.pid):
|
||||
raise ZombieProcess(self.pid, self._name, self._ppid)
|
||||
else:
|
||||
raise NoSuchProcess(self.pid, self._name)
|
||||
except PermissionError:
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
except OSError:
|
||||
if self.pid == 0:
|
||||
if 0 in pids():
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
else:
|
||||
raise
|
||||
raise
|
||||
return wrapper
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def wrap_exceptions_procfs(inst):
|
||||
"""Same as above, for routines relying on reading /proc fs."""
|
||||
try:
|
||||
yield
|
||||
except (ProcessLookupError, FileNotFoundError):
|
||||
# ENOENT (no such file or directory) gets raised on open().
|
||||
# ESRCH (no such process) can get raised on read() if
|
||||
# process is gone in meantime.
|
||||
if is_zombie(inst.pid):
|
||||
raise ZombieProcess(inst.pid, inst._name, inst._ppid)
|
||||
else:
|
||||
raise NoSuchProcess(inst.pid, inst._name)
|
||||
except PermissionError:
|
||||
raise AccessDenied(inst.pid, inst._name)
|
||||
|
||||
|
||||
class Process(object):
|
||||
"""Wrapper class around underlying C implementation."""
|
||||
|
||||
__slots__ = ["pid", "_name", "_ppid", "_cache"]
|
||||
|
||||
def __init__(self, pid):
|
||||
self.pid = pid
|
||||
self._name = None
|
||||
self._ppid = None
|
||||
|
||||
def _assert_alive(self):
|
||||
"""Raise NSP if the process disappeared on us."""
|
||||
# For those C function who do not raise NSP, possibly returning
|
||||
# incorrect or incomplete result.
|
||||
cext.proc_name(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def oneshot(self):
|
||||
"""Retrieves multiple process info in one shot as a raw tuple."""
|
||||
ret = cext.proc_oneshot_info(self.pid)
|
||||
assert len(ret) == len(kinfo_proc_map)
|
||||
return ret
|
||||
|
||||
def oneshot_enter(self):
|
||||
self.oneshot.cache_activate(self)
|
||||
|
||||
def oneshot_exit(self):
|
||||
self.oneshot.cache_deactivate(self)
|
||||
|
||||
@wrap_exceptions
|
||||
def name(self):
|
||||
name = self.oneshot()[kinfo_proc_map['name']]
|
||||
return name if name is not None else cext.proc_name(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def exe(self):
|
||||
if FREEBSD:
|
||||
if self.pid == 0:
|
||||
return '' # else NSP
|
||||
return cext.proc_exe(self.pid)
|
||||
elif NETBSD:
|
||||
if self.pid == 0:
|
||||
# /proc/0 dir exists but /proc/0/exe doesn't
|
||||
return ""
|
||||
with wrap_exceptions_procfs(self):
|
||||
return os.readlink("/proc/%s/exe" % self.pid)
|
||||
else:
|
||||
# OpenBSD: exe cannot be determined; references:
|
||||
# https://chromium.googlesource.com/chromium/src/base/+/
|
||||
# master/base_paths_posix.cc
|
||||
# We try our best guess by using which against the first
|
||||
# cmdline arg (may return None).
|
||||
cmdline = self.cmdline()
|
||||
if cmdline:
|
||||
return which(cmdline[0]) or ""
|
||||
else:
|
||||
return ""
|
||||
|
||||
@wrap_exceptions
|
||||
def cmdline(self):
|
||||
if OPENBSD and self.pid == 0:
|
||||
return [] # ...else it crashes
|
||||
elif NETBSD:
|
||||
# XXX - most of the times the underlying sysctl() call on Net
|
||||
# and Open BSD returns a truncated string.
|
||||
# Also /proc/pid/cmdline behaves the same so it looks
|
||||
# like this is a kernel bug.
|
||||
try:
|
||||
return cext.proc_cmdline(self.pid)
|
||||
except OSError as err:
|
||||
if err.errno == errno.EINVAL:
|
||||
if is_zombie(self.pid):
|
||||
raise ZombieProcess(self.pid, self._name, self._ppid)
|
||||
elif not pid_exists(self.pid):
|
||||
raise NoSuchProcess(self.pid, self._name, self._ppid)
|
||||
else:
|
||||
# XXX: this happens with unicode tests. It means the C
|
||||
# routine is unable to decode invalid unicode chars.
|
||||
return []
|
||||
else:
|
||||
raise
|
||||
else:
|
||||
return cext.proc_cmdline(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def environ(self):
|
||||
return cext.proc_environ(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def terminal(self):
|
||||
tty_nr = self.oneshot()[kinfo_proc_map['ttynr']]
|
||||
tmap = _psposix.get_terminal_map()
|
||||
try:
|
||||
return tmap[tty_nr]
|
||||
except KeyError:
|
||||
return None
|
||||
|
||||
@wrap_exceptions
|
||||
def ppid(self):
|
||||
self._ppid = self.oneshot()[kinfo_proc_map['ppid']]
|
||||
return self._ppid
|
||||
|
||||
@wrap_exceptions
|
||||
def uids(self):
|
||||
rawtuple = self.oneshot()
|
||||
return _common.puids(
|
||||
rawtuple[kinfo_proc_map['real_uid']],
|
||||
rawtuple[kinfo_proc_map['effective_uid']],
|
||||
rawtuple[kinfo_proc_map['saved_uid']])
|
||||
|
||||
@wrap_exceptions
|
||||
def gids(self):
|
||||
rawtuple = self.oneshot()
|
||||
return _common.pgids(
|
||||
rawtuple[kinfo_proc_map['real_gid']],
|
||||
rawtuple[kinfo_proc_map['effective_gid']],
|
||||
rawtuple[kinfo_proc_map['saved_gid']])
|
||||
|
||||
@wrap_exceptions
|
||||
def cpu_times(self):
|
||||
rawtuple = self.oneshot()
|
||||
return _common.pcputimes(
|
||||
rawtuple[kinfo_proc_map['user_time']],
|
||||
rawtuple[kinfo_proc_map['sys_time']],
|
||||
rawtuple[kinfo_proc_map['ch_user_time']],
|
||||
rawtuple[kinfo_proc_map['ch_sys_time']])
|
||||
|
||||
if FREEBSD:
|
||||
@wrap_exceptions
|
||||
def cpu_num(self):
|
||||
return self.oneshot()[kinfo_proc_map['cpunum']]
|
||||
|
||||
@wrap_exceptions
|
||||
def memory_info(self):
|
||||
rawtuple = self.oneshot()
|
||||
return pmem(
|
||||
rawtuple[kinfo_proc_map['rss']],
|
||||
rawtuple[kinfo_proc_map['vms']],
|
||||
rawtuple[kinfo_proc_map['memtext']],
|
||||
rawtuple[kinfo_proc_map['memdata']],
|
||||
rawtuple[kinfo_proc_map['memstack']])
|
||||
|
||||
memory_full_info = memory_info
|
||||
|
||||
@wrap_exceptions
|
||||
def create_time(self):
|
||||
return self.oneshot()[kinfo_proc_map['create_time']]
|
||||
|
||||
@wrap_exceptions
|
||||
def num_threads(self):
|
||||
if HAS_PROC_NUM_THREADS:
|
||||
# FreeBSD
|
||||
return cext.proc_num_threads(self.pid)
|
||||
else:
|
||||
return len(self.threads())
|
||||
|
||||
@wrap_exceptions
|
||||
def num_ctx_switches(self):
|
||||
rawtuple = self.oneshot()
|
||||
return _common.pctxsw(
|
||||
rawtuple[kinfo_proc_map['ctx_switches_vol']],
|
||||
rawtuple[kinfo_proc_map['ctx_switches_unvol']])
|
||||
|
||||
@wrap_exceptions
|
||||
def threads(self):
|
||||
# Note: on OpenSBD this (/dev/mem) requires root access.
|
||||
rawlist = cext.proc_threads(self.pid)
|
||||
retlist = []
|
||||
for thread_id, utime, stime in rawlist:
|
||||
ntuple = _common.pthread(thread_id, utime, stime)
|
||||
retlist.append(ntuple)
|
||||
if OPENBSD:
|
||||
self._assert_alive()
|
||||
return retlist
|
||||
|
||||
@wrap_exceptions
|
||||
def connections(self, kind='inet'):
|
||||
if kind not in conn_tmap:
|
||||
raise ValueError("invalid %r kind argument; choose between %s"
|
||||
% (kind, ', '.join([repr(x) for x in conn_tmap])))
|
||||
families, types = conn_tmap[kind]
|
||||
ret = []
|
||||
|
||||
if NETBSD:
|
||||
rawlist = cext.net_connections(self.pid)
|
||||
elif OPENBSD:
|
||||
rawlist = cext.net_connections(self.pid, families, types)
|
||||
else: # FreeBSD
|
||||
rawlist = cext.proc_connections(self.pid, families, types)
|
||||
|
||||
for item in rawlist:
|
||||
fd, fam, type, laddr, raddr, status = item[:6]
|
||||
if NETBSD:
|
||||
# FreeBSD and OpenBSD implement filtering in C
|
||||
if (fam not in families) or (type not in types):
|
||||
continue
|
||||
nt = conn_to_ntuple(fd, fam, type, laddr, raddr, status,
|
||||
TCP_STATUSES)
|
||||
ret.append(nt)
|
||||
|
||||
self._assert_alive()
|
||||
return ret
|
||||
|
||||
@wrap_exceptions
|
||||
def wait(self, timeout=None):
|
||||
return _psposix.wait_pid(self.pid, timeout, self._name)
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_get(self):
|
||||
return cext_posix.getpriority(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_set(self, value):
|
||||
return cext_posix.setpriority(self.pid, value)
|
||||
|
||||
@wrap_exceptions
|
||||
def status(self):
|
||||
code = self.oneshot()[kinfo_proc_map['status']]
|
||||
# XXX is '?' legit? (we're not supposed to return it anyway)
|
||||
return PROC_STATUSES.get(code, '?')
|
||||
|
||||
@wrap_exceptions
|
||||
def io_counters(self):
|
||||
rawtuple = self.oneshot()
|
||||
return _common.pio(
|
||||
rawtuple[kinfo_proc_map['read_io_count']],
|
||||
rawtuple[kinfo_proc_map['write_io_count']],
|
||||
-1,
|
||||
-1)
|
||||
|
||||
@wrap_exceptions
|
||||
def cwd(self):
|
||||
"""Return process current working directory."""
|
||||
# sometimes we get an empty string, in which case we turn
|
||||
# it into None
|
||||
if OPENBSD and self.pid == 0:
|
||||
return "" # ...else it would raise EINVAL
|
||||
elif NETBSD or HAS_PROC_OPEN_FILES:
|
||||
# FreeBSD < 8 does not support functions based on
|
||||
# kinfo_getfile() and kinfo_getvmmap()
|
||||
return cext.proc_cwd(self.pid)
|
||||
else:
|
||||
raise NotImplementedError(
|
||||
"supported only starting from FreeBSD 8" if
|
||||
FREEBSD else "")
|
||||
|
||||
nt_mmap_grouped = namedtuple(
|
||||
'mmap', 'path rss, private, ref_count, shadow_count')
|
||||
nt_mmap_ext = namedtuple(
|
||||
'mmap', 'addr, perms path rss, private, ref_count, shadow_count')
|
||||
|
||||
def _not_implemented(self):
|
||||
raise NotImplementedError
|
||||
|
||||
# FreeBSD < 8 does not support functions based on kinfo_getfile()
|
||||
# and kinfo_getvmmap()
|
||||
if HAS_PROC_OPEN_FILES:
|
||||
@wrap_exceptions
|
||||
def open_files(self):
|
||||
"""Return files opened by process as a list of namedtuples."""
|
||||
rawlist = cext.proc_open_files(self.pid)
|
||||
return [_common.popenfile(path, fd) for path, fd in rawlist]
|
||||
else:
|
||||
open_files = _not_implemented
|
||||
|
||||
# FreeBSD < 8 does not support functions based on kinfo_getfile()
|
||||
# and kinfo_getvmmap()
|
||||
if HAS_PROC_NUM_FDS:
|
||||
@wrap_exceptions
|
||||
def num_fds(self):
|
||||
"""Return the number of file descriptors opened by this process."""
|
||||
ret = cext.proc_num_fds(self.pid)
|
||||
if NETBSD:
|
||||
self._assert_alive()
|
||||
return ret
|
||||
else:
|
||||
num_fds = _not_implemented
|
||||
|
||||
# --- FreeBSD only APIs
|
||||
|
||||
if FREEBSD:
|
||||
|
||||
@wrap_exceptions
|
||||
def cpu_affinity_get(self):
|
||||
return cext.proc_cpu_affinity_get(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def cpu_affinity_set(self, cpus):
|
||||
# Pre-emptively check if CPUs are valid because the C
|
||||
# function has a weird behavior in case of invalid CPUs,
|
||||
# see: https://github.com/giampaolo/psutil/issues/586
|
||||
allcpus = tuple(range(len(per_cpu_times())))
|
||||
for cpu in cpus:
|
||||
if cpu not in allcpus:
|
||||
raise ValueError("invalid CPU #%i (choose between %s)"
|
||||
% (cpu, allcpus))
|
||||
try:
|
||||
cext.proc_cpu_affinity_set(self.pid, cpus)
|
||||
except OSError as err:
|
||||
# 'man cpuset_setaffinity' about EDEADLK:
|
||||
# <<the call would leave a thread without a valid CPU to run
|
||||
# on because the set does not overlap with the thread's
|
||||
# anonymous mask>>
|
||||
if err.errno in (errno.EINVAL, errno.EDEADLK):
|
||||
for cpu in cpus:
|
||||
if cpu not in allcpus:
|
||||
raise ValueError(
|
||||
"invalid CPU #%i (choose between %s)" % (
|
||||
cpu, allcpus))
|
||||
raise
|
||||
|
||||
@wrap_exceptions
|
||||
def memory_maps(self):
|
||||
return cext.proc_memory_maps(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def rlimit(self, resource, limits=None):
|
||||
if limits is None:
|
||||
return cext.proc_getrlimit(self.pid, resource)
|
||||
else:
|
||||
if len(limits) != 2:
|
||||
raise ValueError(
|
||||
"second argument must be a (soft, hard) tuple, "
|
||||
"got %s" % repr(limits))
|
||||
soft, hard = limits
|
||||
return cext.proc_setrlimit(self.pid, resource, soft, hard)
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,543 @@
|
|||
# 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.
|
||||
|
||||
"""macOS platform implementation."""
|
||||
|
||||
import errno
|
||||
import functools
|
||||
import os
|
||||
from collections import namedtuple
|
||||
|
||||
from . import _common
|
||||
from . import _psposix
|
||||
from . import _psutil_osx as cext
|
||||
from . import _psutil_posix as cext_posix
|
||||
from ._common import AccessDenied
|
||||
from ._common import NoSuchProcess
|
||||
from ._common import ZombieProcess
|
||||
from ._common import conn_tmap
|
||||
from ._common import conn_to_ntuple
|
||||
from ._common import isfile_strict
|
||||
from ._common import memoize_when_activated
|
||||
from ._common import parse_environ_block
|
||||
from ._common import usage_percent
|
||||
from ._compat import PermissionError
|
||||
from ._compat import ProcessLookupError
|
||||
|
||||
|
||||
__extra__all__ = []
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- globals
|
||||
# =====================================================================
|
||||
|
||||
|
||||
PAGESIZE = cext_posix.getpagesize()
|
||||
AF_LINK = cext_posix.AF_LINK
|
||||
|
||||
TCP_STATUSES = {
|
||||
cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
|
||||
cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
|
||||
cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV,
|
||||
cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
|
||||
cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
|
||||
cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
|
||||
cext.TCPS_CLOSED: _common.CONN_CLOSE,
|
||||
cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
|
||||
cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
|
||||
cext.TCPS_LISTEN: _common.CONN_LISTEN,
|
||||
cext.TCPS_CLOSING: _common.CONN_CLOSING,
|
||||
cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
|
||||
}
|
||||
|
||||
PROC_STATUSES = {
|
||||
cext.SIDL: _common.STATUS_IDLE,
|
||||
cext.SRUN: _common.STATUS_RUNNING,
|
||||
cext.SSLEEP: _common.STATUS_SLEEPING,
|
||||
cext.SSTOP: _common.STATUS_STOPPED,
|
||||
cext.SZOMB: _common.STATUS_ZOMBIE,
|
||||
}
|
||||
|
||||
kinfo_proc_map = dict(
|
||||
ppid=0,
|
||||
ruid=1,
|
||||
euid=2,
|
||||
suid=3,
|
||||
rgid=4,
|
||||
egid=5,
|
||||
sgid=6,
|
||||
ttynr=7,
|
||||
ctime=8,
|
||||
status=9,
|
||||
name=10,
|
||||
)
|
||||
|
||||
pidtaskinfo_map = dict(
|
||||
cpuutime=0,
|
||||
cpustime=1,
|
||||
rss=2,
|
||||
vms=3,
|
||||
pfaults=4,
|
||||
pageins=5,
|
||||
numthreads=6,
|
||||
volctxsw=7,
|
||||
)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- named tuples
|
||||
# =====================================================================
|
||||
|
||||
|
||||
# psutil.cpu_times()
|
||||
scputimes = namedtuple('scputimes', ['user', 'nice', 'system', 'idle'])
|
||||
# psutil.virtual_memory()
|
||||
svmem = namedtuple(
|
||||
'svmem', ['total', 'available', 'percent', 'used', 'free',
|
||||
'active', 'inactive', 'wired'])
|
||||
# psutil.Process.memory_info()
|
||||
pmem = namedtuple('pmem', ['rss', 'vms', 'pfaults', 'pageins'])
|
||||
# psutil.Process.memory_full_info()
|
||||
pfullmem = namedtuple('pfullmem', pmem._fields + ('uss', ))
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- memory
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def virtual_memory():
|
||||
"""System virtual memory as a namedtuple."""
|
||||
total, active, inactive, wired, free, speculative = cext.virtual_mem()
|
||||
# This is how Zabbix calculate avail and used mem:
|
||||
# https://github.com/zabbix/zabbix/blob/trunk/src/libs/zbxsysinfo/
|
||||
# osx/memory.c
|
||||
# Also see: https://github.com/giampaolo/psutil/issues/1277
|
||||
avail = inactive + free
|
||||
used = active + wired
|
||||
# This is NOT how Zabbix calculates free mem but it matches "free"
|
||||
# cmdline utility.
|
||||
free -= speculative
|
||||
percent = usage_percent((total - avail), total, round_=1)
|
||||
return svmem(total, avail, percent, used, free,
|
||||
active, inactive, wired)
|
||||
|
||||
|
||||
def swap_memory():
|
||||
"""Swap system memory as a (total, used, free, sin, sout) tuple."""
|
||||
total, used, free, sin, sout = cext.swap_mem()
|
||||
percent = usage_percent(used, total, round_=1)
|
||||
return _common.sswap(total, used, free, percent, sin, sout)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- CPU
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def cpu_times():
|
||||
"""Return system CPU times as a namedtuple."""
|
||||
user, nice, system, idle = cext.cpu_times()
|
||||
return scputimes(user, nice, system, idle)
|
||||
|
||||
|
||||
def per_cpu_times():
|
||||
"""Return system CPU times as a named tuple"""
|
||||
ret = []
|
||||
for cpu_t in cext.per_cpu_times():
|
||||
user, nice, system, idle = cpu_t
|
||||
item = scputimes(user, nice, system, idle)
|
||||
ret.append(item)
|
||||
return ret
|
||||
|
||||
|
||||
def cpu_count_logical():
|
||||
"""Return the number of logical CPUs in the system."""
|
||||
return cext.cpu_count_logical()
|
||||
|
||||
|
||||
def cpu_count_cores():
|
||||
"""Return the number of CPU cores in the system."""
|
||||
return cext.cpu_count_cores()
|
||||
|
||||
|
||||
def cpu_stats():
|
||||
ctx_switches, interrupts, soft_interrupts, syscalls, traps = \
|
||||
cext.cpu_stats()
|
||||
return _common.scpustats(
|
||||
ctx_switches, interrupts, soft_interrupts, syscalls)
|
||||
|
||||
|
||||
def cpu_freq():
|
||||
"""Return CPU frequency.
|
||||
On macOS per-cpu frequency is not supported.
|
||||
Also, the returned frequency never changes, see:
|
||||
https://arstechnica.com/civis/viewtopic.php?f=19&t=465002
|
||||
"""
|
||||
curr, min_, max_ = cext.cpu_freq()
|
||||
return [_common.scpufreq(curr, min_, max_)]
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- disks
|
||||
# =====================================================================
|
||||
|
||||
|
||||
disk_usage = _psposix.disk_usage
|
||||
disk_io_counters = cext.disk_io_counters
|
||||
|
||||
|
||||
def disk_partitions(all=False):
|
||||
"""Return mounted disk partitions as a list of namedtuples."""
|
||||
retlist = []
|
||||
partitions = cext.disk_partitions()
|
||||
for partition in partitions:
|
||||
device, mountpoint, fstype, opts = partition
|
||||
if device == 'none':
|
||||
device = ''
|
||||
if not all:
|
||||
if not os.path.isabs(device) or not os.path.exists(device):
|
||||
continue
|
||||
maxfile = maxpath = None # set later
|
||||
ntuple = _common.sdiskpart(device, mountpoint, fstype, opts,
|
||||
maxfile, maxpath)
|
||||
retlist.append(ntuple)
|
||||
return retlist
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- sensors
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def sensors_battery():
|
||||
"""Return battery information."""
|
||||
try:
|
||||
percent, minsleft, power_plugged = cext.sensors_battery()
|
||||
except NotImplementedError:
|
||||
# no power source - return None according to interface
|
||||
return None
|
||||
power_plugged = power_plugged == 1
|
||||
if power_plugged:
|
||||
secsleft = _common.POWER_TIME_UNLIMITED
|
||||
elif minsleft == -1:
|
||||
secsleft = _common.POWER_TIME_UNKNOWN
|
||||
else:
|
||||
secsleft = minsleft * 60
|
||||
return _common.sbattery(percent, secsleft, power_plugged)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- network
|
||||
# =====================================================================
|
||||
|
||||
|
||||
net_io_counters = cext.net_io_counters
|
||||
net_if_addrs = cext_posix.net_if_addrs
|
||||
|
||||
|
||||
def net_connections(kind='inet'):
|
||||
"""System-wide network connections."""
|
||||
# Note: on macOS this will fail with AccessDenied unless
|
||||
# the process is owned by root.
|
||||
ret = []
|
||||
for pid in pids():
|
||||
try:
|
||||
cons = Process(pid).connections(kind)
|
||||
except NoSuchProcess:
|
||||
continue
|
||||
else:
|
||||
if cons:
|
||||
for c in cons:
|
||||
c = list(c) + [pid]
|
||||
ret.append(_common.sconn(*c))
|
||||
return ret
|
||||
|
||||
|
||||
def net_if_stats():
|
||||
"""Get NIC stats (isup, duplex, speed, mtu)."""
|
||||
names = net_io_counters().keys()
|
||||
ret = {}
|
||||
for name in names:
|
||||
try:
|
||||
mtu = cext_posix.net_if_mtu(name)
|
||||
flags = cext_posix.net_if_flags(name)
|
||||
duplex, speed = cext_posix.net_if_duplex_speed(name)
|
||||
except OSError as err:
|
||||
# https://github.com/giampaolo/psutil/issues/1279
|
||||
if err.errno != errno.ENODEV:
|
||||
raise
|
||||
else:
|
||||
if hasattr(_common, 'NicDuplex'):
|
||||
duplex = _common.NicDuplex(duplex)
|
||||
output_flags = ','.join(flags)
|
||||
isup = 'running' in flags
|
||||
ret[name] = _common.snicstats(isup, duplex, speed, mtu,
|
||||
output_flags)
|
||||
return ret
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- other system functions
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def boot_time():
|
||||
"""The system boot time expressed in seconds since the epoch."""
|
||||
return cext.boot_time()
|
||||
|
||||
|
||||
def users():
|
||||
"""Return currently connected users as a list of namedtuples."""
|
||||
retlist = []
|
||||
rawlist = cext.users()
|
||||
for item in rawlist:
|
||||
user, tty, hostname, tstamp, pid = item
|
||||
if tty == '~':
|
||||
continue # reboot or shutdown
|
||||
if not tstamp:
|
||||
continue
|
||||
nt = _common.suser(user, tty or None, hostname or None, tstamp, pid)
|
||||
retlist.append(nt)
|
||||
return retlist
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- processes
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def pids():
|
||||
ls = cext.pids()
|
||||
if 0 not in ls:
|
||||
# On certain macOS versions pids() C doesn't return PID 0 but
|
||||
# "ps" does and the process is querable via sysctl():
|
||||
# https://travis-ci.org/giampaolo/psutil/jobs/309619941
|
||||
try:
|
||||
Process(0).create_time()
|
||||
ls.insert(0, 0)
|
||||
except NoSuchProcess:
|
||||
pass
|
||||
except AccessDenied:
|
||||
ls.insert(0, 0)
|
||||
return ls
|
||||
|
||||
|
||||
pid_exists = _psposix.pid_exists
|
||||
|
||||
|
||||
def is_zombie(pid):
|
||||
try:
|
||||
st = cext.proc_kinfo_oneshot(pid)[kinfo_proc_map['status']]
|
||||
return st == cext.SZOMB
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def wrap_exceptions(fun):
|
||||
"""Decorator which translates bare OSError exceptions into
|
||||
NoSuchProcess and AccessDenied.
|
||||
"""
|
||||
@functools.wraps(fun)
|
||||
def wrapper(self, *args, **kwargs):
|
||||
try:
|
||||
return fun(self, *args, **kwargs)
|
||||
except ProcessLookupError:
|
||||
if is_zombie(self.pid):
|
||||
raise ZombieProcess(self.pid, self._name, self._ppid)
|
||||
else:
|
||||
raise NoSuchProcess(self.pid, self._name)
|
||||
except PermissionError:
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
except cext.ZombieProcessError:
|
||||
raise ZombieProcess(self.pid, self._name, self._ppid)
|
||||
return wrapper
|
||||
|
||||
|
||||
class Process(object):
|
||||
"""Wrapper class around underlying C implementation."""
|
||||
|
||||
__slots__ = ["pid", "_name", "_ppid", "_cache"]
|
||||
|
||||
def __init__(self, pid):
|
||||
self.pid = pid
|
||||
self._name = None
|
||||
self._ppid = None
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def _get_kinfo_proc(self):
|
||||
# Note: should work with all PIDs without permission issues.
|
||||
ret = cext.proc_kinfo_oneshot(self.pid)
|
||||
assert len(ret) == len(kinfo_proc_map)
|
||||
return ret
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def _get_pidtaskinfo(self):
|
||||
# Note: should work for PIDs owned by user only.
|
||||
ret = cext.proc_pidtaskinfo_oneshot(self.pid)
|
||||
assert len(ret) == len(pidtaskinfo_map)
|
||||
return ret
|
||||
|
||||
def oneshot_enter(self):
|
||||
self._get_kinfo_proc.cache_activate(self)
|
||||
self._get_pidtaskinfo.cache_activate(self)
|
||||
|
||||
def oneshot_exit(self):
|
||||
self._get_kinfo_proc.cache_deactivate(self)
|
||||
self._get_pidtaskinfo.cache_deactivate(self)
|
||||
|
||||
@wrap_exceptions
|
||||
def name(self):
|
||||
name = self._get_kinfo_proc()[kinfo_proc_map['name']]
|
||||
return name if name is not None else cext.proc_name(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def exe(self):
|
||||
return cext.proc_exe(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def cmdline(self):
|
||||
return cext.proc_cmdline(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def environ(self):
|
||||
return parse_environ_block(cext.proc_environ(self.pid))
|
||||
|
||||
@wrap_exceptions
|
||||
def ppid(self):
|
||||
self._ppid = self._get_kinfo_proc()[kinfo_proc_map['ppid']]
|
||||
return self._ppid
|
||||
|
||||
@wrap_exceptions
|
||||
def cwd(self):
|
||||
return cext.proc_cwd(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def uids(self):
|
||||
rawtuple = self._get_kinfo_proc()
|
||||
return _common.puids(
|
||||
rawtuple[kinfo_proc_map['ruid']],
|
||||
rawtuple[kinfo_proc_map['euid']],
|
||||
rawtuple[kinfo_proc_map['suid']])
|
||||
|
||||
@wrap_exceptions
|
||||
def gids(self):
|
||||
rawtuple = self._get_kinfo_proc()
|
||||
return _common.puids(
|
||||
rawtuple[kinfo_proc_map['rgid']],
|
||||
rawtuple[kinfo_proc_map['egid']],
|
||||
rawtuple[kinfo_proc_map['sgid']])
|
||||
|
||||
@wrap_exceptions
|
||||
def terminal(self):
|
||||
tty_nr = self._get_kinfo_proc()[kinfo_proc_map['ttynr']]
|
||||
tmap = _psposix.get_terminal_map()
|
||||
try:
|
||||
return tmap[tty_nr]
|
||||
except KeyError:
|
||||
return None
|
||||
|
||||
@wrap_exceptions
|
||||
def memory_info(self):
|
||||
rawtuple = self._get_pidtaskinfo()
|
||||
return pmem(
|
||||
rawtuple[pidtaskinfo_map['rss']],
|
||||
rawtuple[pidtaskinfo_map['vms']],
|
||||
rawtuple[pidtaskinfo_map['pfaults']],
|
||||
rawtuple[pidtaskinfo_map['pageins']],
|
||||
)
|
||||
|
||||
@wrap_exceptions
|
||||
def memory_full_info(self):
|
||||
basic_mem = self.memory_info()
|
||||
uss = cext.proc_memory_uss(self.pid)
|
||||
return pfullmem(*basic_mem + (uss, ))
|
||||
|
||||
@wrap_exceptions
|
||||
def cpu_times(self):
|
||||
rawtuple = self._get_pidtaskinfo()
|
||||
return _common.pcputimes(
|
||||
rawtuple[pidtaskinfo_map['cpuutime']],
|
||||
rawtuple[pidtaskinfo_map['cpustime']],
|
||||
# children user / system times are not retrievable (set to 0)
|
||||
0.0, 0.0)
|
||||
|
||||
@wrap_exceptions
|
||||
def create_time(self):
|
||||
return self._get_kinfo_proc()[kinfo_proc_map['ctime']]
|
||||
|
||||
@wrap_exceptions
|
||||
def num_ctx_switches(self):
|
||||
# Unvoluntary value seems not to be available;
|
||||
# getrusage() numbers seems to confirm this theory.
|
||||
# We set it to 0.
|
||||
vol = self._get_pidtaskinfo()[pidtaskinfo_map['volctxsw']]
|
||||
return _common.pctxsw(vol, 0)
|
||||
|
||||
@wrap_exceptions
|
||||
def num_threads(self):
|
||||
return self._get_pidtaskinfo()[pidtaskinfo_map['numthreads']]
|
||||
|
||||
@wrap_exceptions
|
||||
def open_files(self):
|
||||
if self.pid == 0:
|
||||
return []
|
||||
files = []
|
||||
rawlist = cext.proc_open_files(self.pid)
|
||||
for path, fd in rawlist:
|
||||
if isfile_strict(path):
|
||||
ntuple = _common.popenfile(path, fd)
|
||||
files.append(ntuple)
|
||||
return files
|
||||
|
||||
@wrap_exceptions
|
||||
def connections(self, kind='inet'):
|
||||
if kind not in conn_tmap:
|
||||
raise ValueError("invalid %r kind argument; choose between %s"
|
||||
% (kind, ', '.join([repr(x) for x in conn_tmap])))
|
||||
families, types = conn_tmap[kind]
|
||||
rawlist = cext.proc_connections(self.pid, families, types)
|
||||
ret = []
|
||||
for item in rawlist:
|
||||
fd, fam, type, laddr, raddr, status = item
|
||||
nt = conn_to_ntuple(fd, fam, type, laddr, raddr, status,
|
||||
TCP_STATUSES)
|
||||
ret.append(nt)
|
||||
return ret
|
||||
|
||||
@wrap_exceptions
|
||||
def num_fds(self):
|
||||
if self.pid == 0:
|
||||
return 0
|
||||
return cext.proc_num_fds(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def wait(self, timeout=None):
|
||||
return _psposix.wait_pid(self.pid, timeout, self._name)
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_get(self):
|
||||
return cext_posix.getpriority(self.pid)
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_set(self, value):
|
||||
return cext_posix.setpriority(self.pid, value)
|
||||
|
||||
@wrap_exceptions
|
||||
def status(self):
|
||||
code = self._get_kinfo_proc()[kinfo_proc_map['status']]
|
||||
# XXX is '?' legit? (we're not supposed to return it anyway)
|
||||
return PROC_STATUSES.get(code, '?')
|
||||
|
||||
@wrap_exceptions
|
||||
def threads(self):
|
||||
rawlist = cext.proc_threads(self.pid)
|
||||
retlist = []
|
||||
for thread_id, utime, stime in rawlist:
|
||||
ntuple = _common.pthread(thread_id, utime, stime)
|
||||
retlist.append(ntuple)
|
||||
return retlist
|
|
@ -0,0 +1,232 @@
|
|||
# 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.
|
||||
|
||||
"""Routines common to all posix systems."""
|
||||
|
||||
import glob
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
import time
|
||||
|
||||
from ._common import MACOS
|
||||
from ._common import TimeoutExpired
|
||||
from ._common import memoize
|
||||
from ._common import sdiskusage
|
||||
from ._common import usage_percent
|
||||
from ._compat import PY3
|
||||
from ._compat import ChildProcessError
|
||||
from ._compat import FileNotFoundError
|
||||
from ._compat import InterruptedError
|
||||
from ._compat import PermissionError
|
||||
from ._compat import ProcessLookupError
|
||||
from ._compat import unicode
|
||||
|
||||
|
||||
if MACOS:
|
||||
from . import _psutil_osx
|
||||
|
||||
|
||||
if sys.version_info >= (3, 4):
|
||||
import enum
|
||||
else:
|
||||
enum = None
|
||||
|
||||
|
||||
__all__ = ['pid_exists', 'wait_pid', 'disk_usage', 'get_terminal_map']
|
||||
|
||||
|
||||
def pid_exists(pid):
|
||||
"""Check whether pid exists in the current process table."""
|
||||
if pid == 0:
|
||||
# According to "man 2 kill" PID 0 has a special meaning:
|
||||
# it refers to <<every process in the process group of the
|
||||
# calling process>> so we don't want to go any further.
|
||||
# If we get here it means this UNIX platform *does* have
|
||||
# a process with id 0.
|
||||
return True
|
||||
try:
|
||||
os.kill(pid, 0)
|
||||
except ProcessLookupError:
|
||||
return False
|
||||
except PermissionError:
|
||||
# EPERM clearly means there's a process to deny access to
|
||||
return True
|
||||
# According to "man 2 kill" possible error values are
|
||||
# (EINVAL, EPERM, ESRCH)
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
# Python 3.5 signals enum (contributed by me ^^):
|
||||
# https://bugs.python.org/issue21076
|
||||
if enum is not None and hasattr(signal, "Signals"):
|
||||
Negsignal = enum.IntEnum(
|
||||
'Negsignal', dict([(x.name, -x.value) for x in signal.Signals]))
|
||||
|
||||
def negsig_to_enum(num):
|
||||
"""Convert a negative signal value to an enum."""
|
||||
try:
|
||||
return Negsignal(num)
|
||||
except ValueError:
|
||||
return num
|
||||
else: # pragma: no cover
|
||||
def negsig_to_enum(num):
|
||||
return num
|
||||
|
||||
|
||||
def wait_pid(pid, timeout=None, proc_name=None,
|
||||
_waitpid=os.waitpid,
|
||||
_timer=getattr(time, 'monotonic', time.time),
|
||||
_min=min,
|
||||
_sleep=time.sleep,
|
||||
_pid_exists=pid_exists):
|
||||
"""Wait for a process PID to terminate.
|
||||
|
||||
If the process terminated normally by calling exit(3) or _exit(2),
|
||||
or by returning from main(), the return value is the positive integer
|
||||
passed to *exit().
|
||||
|
||||
If it was terminated by a signal it returns the negated value of the
|
||||
signal which caused the termination (e.g. -SIGTERM).
|
||||
|
||||
If PID is not a children of os.getpid() (current process) just
|
||||
wait until the process disappears and return None.
|
||||
|
||||
If PID does not exist at all return None immediately.
|
||||
|
||||
If *timeout* != None and process is still alive raise TimeoutExpired.
|
||||
timeout=0 is also possible (either return immediately or raise).
|
||||
"""
|
||||
if pid <= 0:
|
||||
raise ValueError("can't wait for PID 0") # see "man waitpid"
|
||||
interval = 0.0001
|
||||
flags = 0
|
||||
if timeout is not None:
|
||||
flags |= os.WNOHANG
|
||||
stop_at = _timer() + timeout
|
||||
|
||||
def sleep(interval):
|
||||
# Sleep for some time and return a new increased interval.
|
||||
if timeout is not None:
|
||||
if _timer() >= stop_at:
|
||||
raise TimeoutExpired(timeout, pid=pid, name=proc_name)
|
||||
_sleep(interval)
|
||||
return _min(interval * 2, 0.04)
|
||||
|
||||
# See: https://linux.die.net/man/2/waitpid
|
||||
while True:
|
||||
try:
|
||||
retpid, status = os.waitpid(pid, flags)
|
||||
except InterruptedError:
|
||||
interval = sleep(interval)
|
||||
except ChildProcessError:
|
||||
# This has two meanings:
|
||||
# - PID is not a child of os.getpid() in which case
|
||||
# we keep polling until it's gone
|
||||
# - PID never existed in the first place
|
||||
# In both cases we'll eventually return None as we
|
||||
# can't determine its exit status code.
|
||||
while _pid_exists(pid):
|
||||
interval = sleep(interval)
|
||||
return
|
||||
else:
|
||||
if retpid == 0:
|
||||
# WNOHANG flag was used and PID is still running.
|
||||
interval = sleep(interval)
|
||||
continue
|
||||
elif os.WIFEXITED(status):
|
||||
# Process terminated normally by calling exit(3) or _exit(2),
|
||||
# or by returning from main(). The return value is the
|
||||
# positive integer passed to *exit().
|
||||
return os.WEXITSTATUS(status)
|
||||
elif os.WIFSIGNALED(status):
|
||||
# Process exited due to a signal. Return the negative value
|
||||
# of that signal.
|
||||
return negsig_to_enum(-os.WTERMSIG(status))
|
||||
# elif os.WIFSTOPPED(status):
|
||||
# # Process was stopped via SIGSTOP or is being traced, and
|
||||
# # waitpid() was called with WUNTRACED flag. PID is still
|
||||
# # alive. From now on waitpid() will keep returning (0, 0)
|
||||
# # until the process state doesn't change.
|
||||
# # It may make sense to catch/enable this since stopped PIDs
|
||||
# # ignore SIGTERM.
|
||||
# interval = sleep(interval)
|
||||
# continue
|
||||
# elif os.WIFCONTINUED(status):
|
||||
# # Process was resumed via SIGCONT and waitpid() was called
|
||||
# # with WCONTINUED flag.
|
||||
# interval = sleep(interval)
|
||||
# continue
|
||||
else:
|
||||
# Should never happen.
|
||||
raise ValueError("unknown process exit status %r" % status)
|
||||
|
||||
|
||||
def disk_usage(path):
|
||||
"""Return disk usage associated with path.
|
||||
Note: UNIX usually reserves 5% disk space which is not accessible
|
||||
by user. In this function "total" and "used" values reflect the
|
||||
total and used disk space whereas "free" and "percent" represent
|
||||
the "free" and "used percent" user disk space.
|
||||
"""
|
||||
if PY3:
|
||||
st = os.statvfs(path)
|
||||
else: # pragma: no cover
|
||||
# os.statvfs() does not support unicode on Python 2:
|
||||
# - https://github.com/giampaolo/psutil/issues/416
|
||||
# - http://bugs.python.org/issue18695
|
||||
try:
|
||||
st = os.statvfs(path)
|
||||
except UnicodeEncodeError:
|
||||
if isinstance(path, unicode):
|
||||
try:
|
||||
path = path.encode(sys.getfilesystemencoding())
|
||||
except UnicodeEncodeError:
|
||||
pass
|
||||
st = os.statvfs(path)
|
||||
else:
|
||||
raise
|
||||
|
||||
# Total space which is only available to root (unless changed
|
||||
# at system level).
|
||||
total = (st.f_blocks * st.f_frsize)
|
||||
# Remaining free space usable by root.
|
||||
avail_to_root = (st.f_bfree * st.f_frsize)
|
||||
# Remaining free space usable by user.
|
||||
avail_to_user = (st.f_bavail * st.f_frsize)
|
||||
# Total space being used in general.
|
||||
used = (total - avail_to_root)
|
||||
if MACOS:
|
||||
# see: https://github.com/giampaolo/psutil/pull/2152
|
||||
used = _psutil_osx.disk_usage_used(path, used)
|
||||
# Total space which is available to user (same as 'total' but
|
||||
# for the user).
|
||||
total_user = used + avail_to_user
|
||||
# User usage percent compared to the total amount of space
|
||||
# the user can use. This number would be higher if compared
|
||||
# to root's because the user has less space (usually -5%).
|
||||
usage_percent_user = usage_percent(used, total_user, round_=1)
|
||||
|
||||
# NB: the percentage is -5% than what shown by df due to
|
||||
# reserved blocks that we are currently not considering:
|
||||
# https://github.com/giampaolo/psutil/issues/829#issuecomment-223750462
|
||||
return sdiskusage(
|
||||
total=total, used=used, free=avail_to_user, percent=usage_percent_user)
|
||||
|
||||
|
||||
@memoize
|
||||
def get_terminal_map():
|
||||
"""Get a map of device-id -> path as a dict.
|
||||
Used by Process.terminal()
|
||||
"""
|
||||
ret = {}
|
||||
ls = glob.glob('/dev/tty*') + glob.glob('/dev/pts/*')
|
||||
for name in ls:
|
||||
assert name not in ret, name
|
||||
try:
|
||||
ret[os.stat(name).st_rdev] = name
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
return ret
|
|
@ -0,0 +1,727 @@
|
|||
# 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.
|
||||
|
||||
"""Sun OS Solaris platform implementation."""
|
||||
|
||||
import errno
|
||||
import functools
|
||||
import os
|
||||
import socket
|
||||
import subprocess
|
||||
import sys
|
||||
from collections import namedtuple
|
||||
from socket import AF_INET
|
||||
|
||||
from . import _common
|
||||
from . import _psposix
|
||||
from . import _psutil_posix as cext_posix
|
||||
from . import _psutil_sunos as cext
|
||||
from ._common import AF_INET6
|
||||
from ._common import AccessDenied
|
||||
from ._common import NoSuchProcess
|
||||
from ._common import ZombieProcess
|
||||
from ._common import debug
|
||||
from ._common import get_procfs_path
|
||||
from ._common import isfile_strict
|
||||
from ._common import memoize_when_activated
|
||||
from ._common import sockfam_to_enum
|
||||
from ._common import socktype_to_enum
|
||||
from ._common import usage_percent
|
||||
from ._compat import PY3
|
||||
from ._compat import FileNotFoundError
|
||||
from ._compat import PermissionError
|
||||
from ._compat import ProcessLookupError
|
||||
from ._compat import b
|
||||
|
||||
|
||||
__extra__all__ = ["CONN_IDLE", "CONN_BOUND", "PROCFS_PATH"]
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- globals
|
||||
# =====================================================================
|
||||
|
||||
|
||||
PAGE_SIZE = cext_posix.getpagesize()
|
||||
AF_LINK = cext_posix.AF_LINK
|
||||
IS_64_BIT = sys.maxsize > 2**32
|
||||
|
||||
CONN_IDLE = "IDLE"
|
||||
CONN_BOUND = "BOUND"
|
||||
|
||||
PROC_STATUSES = {
|
||||
cext.SSLEEP: _common.STATUS_SLEEPING,
|
||||
cext.SRUN: _common.STATUS_RUNNING,
|
||||
cext.SZOMB: _common.STATUS_ZOMBIE,
|
||||
cext.SSTOP: _common.STATUS_STOPPED,
|
||||
cext.SIDL: _common.STATUS_IDLE,
|
||||
cext.SONPROC: _common.STATUS_RUNNING, # same as run
|
||||
cext.SWAIT: _common.STATUS_WAITING,
|
||||
}
|
||||
|
||||
TCP_STATUSES = {
|
||||
cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
|
||||
cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
|
||||
cext.TCPS_SYN_RCVD: _common.CONN_SYN_RECV,
|
||||
cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
|
||||
cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
|
||||
cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
|
||||
cext.TCPS_CLOSED: _common.CONN_CLOSE,
|
||||
cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
|
||||
cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
|
||||
cext.TCPS_LISTEN: _common.CONN_LISTEN,
|
||||
cext.TCPS_CLOSING: _common.CONN_CLOSING,
|
||||
cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
|
||||
cext.TCPS_IDLE: CONN_IDLE, # sunos specific
|
||||
cext.TCPS_BOUND: CONN_BOUND, # sunos specific
|
||||
}
|
||||
|
||||
proc_info_map = dict(
|
||||
ppid=0,
|
||||
rss=1,
|
||||
vms=2,
|
||||
create_time=3,
|
||||
nice=4,
|
||||
num_threads=5,
|
||||
status=6,
|
||||
ttynr=7,
|
||||
uid=8,
|
||||
euid=9,
|
||||
gid=10,
|
||||
egid=11)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- named tuples
|
||||
# =====================================================================
|
||||
|
||||
|
||||
# psutil.cpu_times()
|
||||
scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'iowait'])
|
||||
# psutil.cpu_times(percpu=True)
|
||||
pcputimes = namedtuple('pcputimes',
|
||||
['user', 'system', 'children_user', 'children_system'])
|
||||
# psutil.virtual_memory()
|
||||
svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free'])
|
||||
# psutil.Process.memory_info()
|
||||
pmem = namedtuple('pmem', ['rss', 'vms'])
|
||||
pfullmem = pmem
|
||||
# psutil.Process.memory_maps(grouped=True)
|
||||
pmmap_grouped = namedtuple('pmmap_grouped',
|
||||
['path', 'rss', 'anonymous', 'locked'])
|
||||
# psutil.Process.memory_maps(grouped=False)
|
||||
pmmap_ext = namedtuple(
|
||||
'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- memory
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def virtual_memory():
|
||||
"""Report virtual memory metrics."""
|
||||
# we could have done this with kstat, but IMHO this is good enough
|
||||
total = os.sysconf('SC_PHYS_PAGES') * PAGE_SIZE
|
||||
# note: there's no difference on Solaris
|
||||
free = avail = os.sysconf('SC_AVPHYS_PAGES') * PAGE_SIZE
|
||||
used = total - free
|
||||
percent = usage_percent(used, total, round_=1)
|
||||
return svmem(total, avail, percent, used, free)
|
||||
|
||||
|
||||
def swap_memory():
|
||||
"""Report swap memory metrics."""
|
||||
sin, sout = cext.swap_mem()
|
||||
# XXX
|
||||
# we are supposed to get total/free by doing so:
|
||||
# http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/
|
||||
# usr/src/cmd/swap/swap.c
|
||||
# ...nevertheless I can't manage to obtain the same numbers as 'swap'
|
||||
# cmdline utility, so let's parse its output (sigh!)
|
||||
p = subprocess.Popen(['/usr/bin/env', 'PATH=/usr/sbin:/sbin:%s' %
|
||||
os.environ['PATH'], 'swap', '-l'],
|
||||
stdout=subprocess.PIPE)
|
||||
stdout, _ = p.communicate()
|
||||
if PY3:
|
||||
stdout = stdout.decode(sys.stdout.encoding)
|
||||
if p.returncode != 0:
|
||||
raise RuntimeError("'swap -l' failed (retcode=%s)" % p.returncode)
|
||||
|
||||
lines = stdout.strip().split('\n')[1:]
|
||||
if not lines:
|
||||
raise RuntimeError('no swap device(s) configured')
|
||||
total = free = 0
|
||||
for line in lines:
|
||||
line = line.split()
|
||||
t, f = line[3:5]
|
||||
total += int(int(t) * 512)
|
||||
free += int(int(f) * 512)
|
||||
used = total - free
|
||||
percent = usage_percent(used, total, round_=1)
|
||||
return _common.sswap(total, used, free, percent,
|
||||
sin * PAGE_SIZE, sout * PAGE_SIZE)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- CPU
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def cpu_times():
|
||||
"""Return system-wide CPU times as a named tuple"""
|
||||
ret = cext.per_cpu_times()
|
||||
return scputimes(*[sum(x) for x in zip(*ret)])
|
||||
|
||||
|
||||
def per_cpu_times():
|
||||
"""Return system per-CPU times as a list of named tuples"""
|
||||
ret = cext.per_cpu_times()
|
||||
return [scputimes(*x) for x in ret]
|
||||
|
||||
|
||||
def cpu_count_logical():
|
||||
"""Return the number of logical CPUs in the system."""
|
||||
try:
|
||||
return os.sysconf("SC_NPROCESSORS_ONLN")
|
||||
except ValueError:
|
||||
# mimic os.cpu_count() behavior
|
||||
return None
|
||||
|
||||
|
||||
def cpu_count_cores():
|
||||
"""Return the number of CPU cores in the system."""
|
||||
return cext.cpu_count_cores()
|
||||
|
||||
|
||||
def cpu_stats():
|
||||
"""Return various CPU stats as a named tuple."""
|
||||
ctx_switches, interrupts, syscalls, traps = cext.cpu_stats()
|
||||
soft_interrupts = 0
|
||||
return _common.scpustats(ctx_switches, interrupts, soft_interrupts,
|
||||
syscalls)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- disks
|
||||
# =====================================================================
|
||||
|
||||
|
||||
disk_io_counters = cext.disk_io_counters
|
||||
disk_usage = _psposix.disk_usage
|
||||
|
||||
|
||||
def disk_partitions(all=False):
|
||||
"""Return system disk partitions."""
|
||||
# TODO - the filtering logic should be better checked so that
|
||||
# it tries to reflect 'df' as much as possible
|
||||
retlist = []
|
||||
partitions = cext.disk_partitions()
|
||||
for partition in partitions:
|
||||
device, mountpoint, fstype, opts = partition
|
||||
if device == 'none':
|
||||
device = ''
|
||||
if not all:
|
||||
# Differently from, say, Linux, we don't have a list of
|
||||
# common fs types so the best we can do, AFAIK, is to
|
||||
# filter by filesystem having a total size > 0.
|
||||
try:
|
||||
if not disk_usage(mountpoint).total:
|
||||
continue
|
||||
except OSError as err:
|
||||
# https://github.com/giampaolo/psutil/issues/1674
|
||||
debug("skipping %r: %s" % (mountpoint, err))
|
||||
continue
|
||||
maxfile = maxpath = None # set later
|
||||
ntuple = _common.sdiskpart(device, mountpoint, fstype, opts,
|
||||
maxfile, maxpath)
|
||||
retlist.append(ntuple)
|
||||
return retlist
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- network
|
||||
# =====================================================================
|
||||
|
||||
|
||||
net_io_counters = cext.net_io_counters
|
||||
net_if_addrs = cext_posix.net_if_addrs
|
||||
|
||||
|
||||
def net_connections(kind, _pid=-1):
|
||||
"""Return socket connections. If pid == -1 return system-wide
|
||||
connections (as opposed to connections opened by one process only).
|
||||
Only INET sockets are returned (UNIX are not).
|
||||
"""
|
||||
cmap = _common.conn_tmap.copy()
|
||||
if _pid == -1:
|
||||
cmap.pop('unix', 0)
|
||||
if kind not in cmap:
|
||||
raise ValueError("invalid %r kind argument; choose between %s"
|
||||
% (kind, ', '.join([repr(x) for x in cmap])))
|
||||
families, types = _common.conn_tmap[kind]
|
||||
rawlist = cext.net_connections(_pid)
|
||||
ret = set()
|
||||
for item in rawlist:
|
||||
fd, fam, type_, laddr, raddr, status, pid = item
|
||||
if fam not in families:
|
||||
continue
|
||||
if type_ not in types:
|
||||
continue
|
||||
# TODO: refactor and use _common.conn_to_ntuple.
|
||||
if fam in (AF_INET, AF_INET6):
|
||||
if laddr:
|
||||
laddr = _common.addr(*laddr)
|
||||
if raddr:
|
||||
raddr = _common.addr(*raddr)
|
||||
status = TCP_STATUSES[status]
|
||||
fam = sockfam_to_enum(fam)
|
||||
type_ = socktype_to_enum(type_)
|
||||
if _pid == -1:
|
||||
nt = _common.sconn(fd, fam, type_, laddr, raddr, status, pid)
|
||||
else:
|
||||
nt = _common.pconn(fd, fam, type_, laddr, raddr, status)
|
||||
ret.add(nt)
|
||||
return list(ret)
|
||||
|
||||
|
||||
def net_if_stats():
|
||||
"""Get NIC stats (isup, duplex, speed, mtu)."""
|
||||
ret = cext.net_if_stats()
|
||||
for name, items in ret.items():
|
||||
isup, duplex, speed, mtu = items
|
||||
if hasattr(_common, 'NicDuplex'):
|
||||
duplex = _common.NicDuplex(duplex)
|
||||
ret[name] = _common.snicstats(isup, duplex, speed, mtu, '')
|
||||
return ret
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- other system functions
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def boot_time():
|
||||
"""The system boot time expressed in seconds since the epoch."""
|
||||
return cext.boot_time()
|
||||
|
||||
|
||||
def users():
|
||||
"""Return currently connected users as a list of namedtuples."""
|
||||
retlist = []
|
||||
rawlist = cext.users()
|
||||
localhost = (':0.0', ':0')
|
||||
for item in rawlist:
|
||||
user, tty, hostname, tstamp, user_process, pid = item
|
||||
# note: the underlying C function includes entries about
|
||||
# system boot, run level and others. We might want
|
||||
# to use them in the future.
|
||||
if not user_process:
|
||||
continue
|
||||
if hostname in localhost:
|
||||
hostname = 'localhost'
|
||||
nt = _common.suser(user, tty, hostname, tstamp, pid)
|
||||
retlist.append(nt)
|
||||
return retlist
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- processes
|
||||
# =====================================================================
|
||||
|
||||
|
||||
def pids():
|
||||
"""Returns a list of PIDs currently running on the system."""
|
||||
return [int(x) for x in os.listdir(b(get_procfs_path())) if x.isdigit()]
|
||||
|
||||
|
||||
def pid_exists(pid):
|
||||
"""Check for the existence of a unix pid."""
|
||||
return _psposix.pid_exists(pid)
|
||||
|
||||
|
||||
def wrap_exceptions(fun):
|
||||
"""Call callable into a try/except clause and translate ENOENT,
|
||||
EACCES and EPERM in NoSuchProcess or AccessDenied exceptions.
|
||||
"""
|
||||
@functools.wraps(fun)
|
||||
def wrapper(self, *args, **kwargs):
|
||||
try:
|
||||
return fun(self, *args, **kwargs)
|
||||
except (FileNotFoundError, ProcessLookupError):
|
||||
# ENOENT (no such file or directory) gets raised on open().
|
||||
# ESRCH (no such process) can get raised on read() if
|
||||
# process is gone in meantime.
|
||||
if not pid_exists(self.pid):
|
||||
raise NoSuchProcess(self.pid, self._name)
|
||||
else:
|
||||
raise ZombieProcess(self.pid, self._name, self._ppid)
|
||||
except PermissionError:
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
except OSError:
|
||||
if self.pid == 0:
|
||||
if 0 in pids():
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
else:
|
||||
raise
|
||||
raise
|
||||
return wrapper
|
||||
|
||||
|
||||
class Process(object):
|
||||
"""Wrapper class around underlying C implementation."""
|
||||
|
||||
__slots__ = ["pid", "_name", "_ppid", "_procfs_path", "_cache"]
|
||||
|
||||
def __init__(self, pid):
|
||||
self.pid = pid
|
||||
self._name = None
|
||||
self._ppid = None
|
||||
self._procfs_path = get_procfs_path()
|
||||
|
||||
def _assert_alive(self):
|
||||
"""Raise NSP if the process disappeared on us."""
|
||||
# For those C function who do not raise NSP, possibly returning
|
||||
# incorrect or incomplete result.
|
||||
os.stat('%s/%s' % (self._procfs_path, self.pid))
|
||||
|
||||
def oneshot_enter(self):
|
||||
self._proc_name_and_args.cache_activate(self)
|
||||
self._proc_basic_info.cache_activate(self)
|
||||
self._proc_cred.cache_activate(self)
|
||||
|
||||
def oneshot_exit(self):
|
||||
self._proc_name_and_args.cache_deactivate(self)
|
||||
self._proc_basic_info.cache_deactivate(self)
|
||||
self._proc_cred.cache_deactivate(self)
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def _proc_name_and_args(self):
|
||||
return cext.proc_name_and_args(self.pid, self._procfs_path)
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def _proc_basic_info(self):
|
||||
if self.pid == 0 and not \
|
||||
os.path.exists('%s/%s/psinfo' % (self._procfs_path, self.pid)):
|
||||
raise AccessDenied(self.pid)
|
||||
ret = cext.proc_basic_info(self.pid, self._procfs_path)
|
||||
assert len(ret) == len(proc_info_map)
|
||||
return ret
|
||||
|
||||
@wrap_exceptions
|
||||
@memoize_when_activated
|
||||
def _proc_cred(self):
|
||||
return cext.proc_cred(self.pid, self._procfs_path)
|
||||
|
||||
@wrap_exceptions
|
||||
def name(self):
|
||||
# note: max len == 15
|
||||
return self._proc_name_and_args()[0]
|
||||
|
||||
@wrap_exceptions
|
||||
def exe(self):
|
||||
try:
|
||||
return os.readlink(
|
||||
"%s/%s/path/a.out" % (self._procfs_path, self.pid))
|
||||
except OSError:
|
||||
pass # continue and guess the exe name from the cmdline
|
||||
# Will be guessed later from cmdline but we want to explicitly
|
||||
# invoke cmdline here in order to get an AccessDenied
|
||||
# exception if the user has not enough privileges.
|
||||
self.cmdline()
|
||||
return ""
|
||||
|
||||
@wrap_exceptions
|
||||
def cmdline(self):
|
||||
return self._proc_name_and_args()[1].split(' ')
|
||||
|
||||
@wrap_exceptions
|
||||
def environ(self):
|
||||
return cext.proc_environ(self.pid, self._procfs_path)
|
||||
|
||||
@wrap_exceptions
|
||||
def create_time(self):
|
||||
return self._proc_basic_info()[proc_info_map['create_time']]
|
||||
|
||||
@wrap_exceptions
|
||||
def num_threads(self):
|
||||
return self._proc_basic_info()[proc_info_map['num_threads']]
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_get(self):
|
||||
# Note #1: getpriority(3) doesn't work for realtime processes.
|
||||
# Psinfo is what ps uses, see:
|
||||
# https://github.com/giampaolo/psutil/issues/1194
|
||||
return self._proc_basic_info()[proc_info_map['nice']]
|
||||
|
||||
@wrap_exceptions
|
||||
def nice_set(self, value):
|
||||
if self.pid in (2, 3):
|
||||
# Special case PIDs: internally setpriority(3) return ESRCH
|
||||
# (no such process), no matter what.
|
||||
# The process actually exists though, as it has a name,
|
||||
# creation time, etc.
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
return cext_posix.setpriority(self.pid, value)
|
||||
|
||||
@wrap_exceptions
|
||||
def ppid(self):
|
||||
self._ppid = self._proc_basic_info()[proc_info_map['ppid']]
|
||||
return self._ppid
|
||||
|
||||
@wrap_exceptions
|
||||
def uids(self):
|
||||
try:
|
||||
real, effective, saved, _, _, _ = self._proc_cred()
|
||||
except AccessDenied:
|
||||
real = self._proc_basic_info()[proc_info_map['uid']]
|
||||
effective = self._proc_basic_info()[proc_info_map['euid']]
|
||||
saved = None
|
||||
return _common.puids(real, effective, saved)
|
||||
|
||||
@wrap_exceptions
|
||||
def gids(self):
|
||||
try:
|
||||
_, _, _, real, effective, saved = self._proc_cred()
|
||||
except AccessDenied:
|
||||
real = self._proc_basic_info()[proc_info_map['gid']]
|
||||
effective = self._proc_basic_info()[proc_info_map['egid']]
|
||||
saved = None
|
||||
return _common.puids(real, effective, saved)
|
||||
|
||||
@wrap_exceptions
|
||||
def cpu_times(self):
|
||||
try:
|
||||
times = cext.proc_cpu_times(self.pid, self._procfs_path)
|
||||
except OSError as err:
|
||||
if err.errno == errno.EOVERFLOW and not IS_64_BIT:
|
||||
# We may get here if we attempt to query a 64bit process
|
||||
# with a 32bit python.
|
||||
# Error originates from read() and also tools like "cat"
|
||||
# fail in the same way (!).
|
||||
# Since there simply is no way to determine CPU times we
|
||||
# return 0.0 as a fallback. See:
|
||||
# https://github.com/giampaolo/psutil/issues/857
|
||||
times = (0.0, 0.0, 0.0, 0.0)
|
||||
else:
|
||||
raise
|
||||
return _common.pcputimes(*times)
|
||||
|
||||
@wrap_exceptions
|
||||
def cpu_num(self):
|
||||
return cext.proc_cpu_num(self.pid, self._procfs_path)
|
||||
|
||||
@wrap_exceptions
|
||||
def terminal(self):
|
||||
procfs_path = self._procfs_path
|
||||
hit_enoent = False
|
||||
tty = wrap_exceptions(
|
||||
self._proc_basic_info()[proc_info_map['ttynr']])
|
||||
if tty != cext.PRNODEV:
|
||||
for x in (0, 1, 2, 255):
|
||||
try:
|
||||
return os.readlink(
|
||||
'%s/%d/path/%d' % (procfs_path, self.pid, x))
|
||||
except FileNotFoundError:
|
||||
hit_enoent = True
|
||||
continue
|
||||
if hit_enoent:
|
||||
self._assert_alive()
|
||||
|
||||
@wrap_exceptions
|
||||
def cwd(self):
|
||||
# /proc/PID/path/cwd may not be resolved by readlink() even if
|
||||
# it exists (ls shows it). If that's the case and the process
|
||||
# is still alive return None (we can return None also on BSD).
|
||||
# Reference: http://goo.gl/55XgO
|
||||
procfs_path = self._procfs_path
|
||||
try:
|
||||
return os.readlink("%s/%s/path/cwd" % (procfs_path, self.pid))
|
||||
except FileNotFoundError:
|
||||
os.stat("%s/%s" % (procfs_path, self.pid)) # raise NSP or AD
|
||||
return ""
|
||||
|
||||
@wrap_exceptions
|
||||
def memory_info(self):
|
||||
ret = self._proc_basic_info()
|
||||
rss = ret[proc_info_map['rss']] * 1024
|
||||
vms = ret[proc_info_map['vms']] * 1024
|
||||
return pmem(rss, vms)
|
||||
|
||||
memory_full_info = memory_info
|
||||
|
||||
@wrap_exceptions
|
||||
def status(self):
|
||||
code = self._proc_basic_info()[proc_info_map['status']]
|
||||
# XXX is '?' legit? (we're not supposed to return it anyway)
|
||||
return PROC_STATUSES.get(code, '?')
|
||||
|
||||
@wrap_exceptions
|
||||
def threads(self):
|
||||
procfs_path = self._procfs_path
|
||||
ret = []
|
||||
tids = os.listdir('%s/%d/lwp' % (procfs_path, self.pid))
|
||||
hit_enoent = False
|
||||
for tid in tids:
|
||||
tid = int(tid)
|
||||
try:
|
||||
utime, stime = cext.query_process_thread(
|
||||
self.pid, tid, procfs_path)
|
||||
except EnvironmentError as err:
|
||||
if err.errno == errno.EOVERFLOW and not IS_64_BIT:
|
||||
# We may get here if we attempt to query a 64bit process
|
||||
# with a 32bit python.
|
||||
# Error originates from read() and also tools like "cat"
|
||||
# fail in the same way (!).
|
||||
# Since there simply is no way to determine CPU times we
|
||||
# return 0.0 as a fallback. See:
|
||||
# https://github.com/giampaolo/psutil/issues/857
|
||||
continue
|
||||
# ENOENT == thread gone in meantime
|
||||
if err.errno == errno.ENOENT:
|
||||
hit_enoent = True
|
||||
continue
|
||||
raise
|
||||
else:
|
||||
nt = _common.pthread(tid, utime, stime)
|
||||
ret.append(nt)
|
||||
if hit_enoent:
|
||||
self._assert_alive()
|
||||
return ret
|
||||
|
||||
@wrap_exceptions
|
||||
def open_files(self):
|
||||
retlist = []
|
||||
hit_enoent = False
|
||||
procfs_path = self._procfs_path
|
||||
pathdir = '%s/%d/path' % (procfs_path, self.pid)
|
||||
for fd in os.listdir('%s/%d/fd' % (procfs_path, self.pid)):
|
||||
path = os.path.join(pathdir, fd)
|
||||
if os.path.islink(path):
|
||||
try:
|
||||
file = os.readlink(path)
|
||||
except FileNotFoundError:
|
||||
hit_enoent = True
|
||||
continue
|
||||
else:
|
||||
if isfile_strict(file):
|
||||
retlist.append(_common.popenfile(file, int(fd)))
|
||||
if hit_enoent:
|
||||
self._assert_alive()
|
||||
return retlist
|
||||
|
||||
def _get_unix_sockets(self, pid):
|
||||
"""Get UNIX sockets used by process by parsing 'pfiles' output."""
|
||||
# TODO: rewrite this in C (...but the damn netstat source code
|
||||
# does not include this part! Argh!!)
|
||||
cmd = "pfiles %s" % pid
|
||||
p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE)
|
||||
stdout, stderr = p.communicate()
|
||||
if PY3:
|
||||
stdout, stderr = [x.decode(sys.stdout.encoding)
|
||||
for x in (stdout, stderr)]
|
||||
if p.returncode != 0:
|
||||
if 'permission denied' in stderr.lower():
|
||||
raise AccessDenied(self.pid, self._name)
|
||||
if 'no such process' in stderr.lower():
|
||||
raise NoSuchProcess(self.pid, self._name)
|
||||
raise RuntimeError("%r command error\n%s" % (cmd, stderr))
|
||||
|
||||
lines = stdout.split('\n')[2:]
|
||||
for i, line in enumerate(lines):
|
||||
line = line.lstrip()
|
||||
if line.startswith('sockname: AF_UNIX'):
|
||||
path = line.split(' ', 2)[2]
|
||||
type = lines[i - 2].strip()
|
||||
if type == 'SOCK_STREAM':
|
||||
type = socket.SOCK_STREAM
|
||||
elif type == 'SOCK_DGRAM':
|
||||
type = socket.SOCK_DGRAM
|
||||
else:
|
||||
type = -1
|
||||
yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE)
|
||||
|
||||
@wrap_exceptions
|
||||
def connections(self, kind='inet'):
|
||||
ret = net_connections(kind, _pid=self.pid)
|
||||
# The underlying C implementation retrieves all OS connections
|
||||
# and filters them by PID. At this point we can't tell whether
|
||||
# an empty list means there were no connections for process or
|
||||
# process is no longer active so we force NSP in case the PID
|
||||
# is no longer there.
|
||||
if not ret:
|
||||
# will raise NSP if process is gone
|
||||
os.stat('%s/%s' % (self._procfs_path, self.pid))
|
||||
|
||||
# UNIX sockets
|
||||
if kind in ('all', 'unix'):
|
||||
ret.extend([_common.pconn(*conn) for conn in
|
||||
self._get_unix_sockets(self.pid)])
|
||||
return ret
|
||||
|
||||
nt_mmap_grouped = namedtuple('mmap', 'path rss anon locked')
|
||||
nt_mmap_ext = namedtuple('mmap', 'addr perms path rss anon locked')
|
||||
|
||||
@wrap_exceptions
|
||||
def memory_maps(self):
|
||||
def toaddr(start, end):
|
||||
return '%s-%s' % (hex(start)[2:].strip('L'),
|
||||
hex(end)[2:].strip('L'))
|
||||
|
||||
procfs_path = self._procfs_path
|
||||
retlist = []
|
||||
try:
|
||||
rawlist = cext.proc_memory_maps(self.pid, procfs_path)
|
||||
except OSError as err:
|
||||
if err.errno == errno.EOVERFLOW and not IS_64_BIT:
|
||||
# We may get here if we attempt to query a 64bit process
|
||||
# with a 32bit python.
|
||||
# Error originates from read() and also tools like "cat"
|
||||
# fail in the same way (!).
|
||||
# Since there simply is no way to determine CPU times we
|
||||
# return 0.0 as a fallback. See:
|
||||
# https://github.com/giampaolo/psutil/issues/857
|
||||
return []
|
||||
else:
|
||||
raise
|
||||
hit_enoent = False
|
||||
for item in rawlist:
|
||||
addr, addrsize, perm, name, rss, anon, locked = item
|
||||
addr = toaddr(addr, addrsize)
|
||||
if not name.startswith('['):
|
||||
try:
|
||||
name = os.readlink(
|
||||
'%s/%s/path/%s' % (procfs_path, self.pid, name))
|
||||
except OSError as err:
|
||||
if err.errno == errno.ENOENT:
|
||||
# sometimes the link may not be resolved by
|
||||
# readlink() even if it exists (ls shows it).
|
||||
# If that's the case we just return the
|
||||
# unresolved link path.
|
||||
# This seems an incosistency with /proc similar
|
||||
# to: http://goo.gl/55XgO
|
||||
name = '%s/%s/path/%s' % (procfs_path, self.pid, name)
|
||||
hit_enoent = True
|
||||
else:
|
||||
raise
|
||||
retlist.append((addr, perm, name, rss, anon, locked))
|
||||
if hit_enoent:
|
||||
self._assert_alive()
|
||||
return retlist
|
||||
|
||||
@wrap_exceptions
|
||||
def num_fds(self):
|
||||
return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid)))
|
||||
|
||||
@wrap_exceptions
|
||||
def num_ctx_switches(self):
|
||||
return _common.pctxsw(
|
||||
*cext.proc_num_ctx_switches(self.pid, self._procfs_path))
|
||||
|
||||
@wrap_exceptions
|
||||
def wait(self, timeout=None):
|
||||
return _psposix.wait_pid(self.pid, timeout, self._name)
|
Binary file not shown.
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,15 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""
|
||||
Run unit tests. This is invoked by:
|
||||
$ python -m psutil.tests
|
||||
"""
|
||||
|
||||
from .runner import main
|
||||
|
||||
|
||||
main()
|
|
@ -0,0 +1,350 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""
|
||||
Unit test runner, providing new features on top of unittest module:
|
||||
- colourized output
|
||||
- parallel run (UNIX only)
|
||||
- print failures/tracebacks on CTRL+C
|
||||
- re-run failed tests only (make test-failed)
|
||||
|
||||
Invocation examples:
|
||||
- make test
|
||||
- make test-failed
|
||||
|
||||
Parallel:
|
||||
- make test-parallel
|
||||
- make test-process ARGS=--parallel
|
||||
"""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import atexit
|
||||
import optparse
|
||||
import os
|
||||
import sys
|
||||
import textwrap
|
||||
import time
|
||||
import unittest
|
||||
|
||||
|
||||
try:
|
||||
import ctypes
|
||||
except ImportError:
|
||||
ctypes = None
|
||||
|
||||
try:
|
||||
import concurrencytest # pip install concurrencytest
|
||||
except ImportError:
|
||||
concurrencytest = None
|
||||
|
||||
import psutil
|
||||
from psutil._common import hilite
|
||||
from psutil._common import print_color
|
||||
from psutil._common import term_supports_colors
|
||||
from psutil._compat import super
|
||||
from psutil.tests import CI_TESTING
|
||||
from psutil.tests import import_module_by_path
|
||||
from psutil.tests import print_sysinfo
|
||||
from psutil.tests import reap_children
|
||||
from psutil.tests import safe_rmpath
|
||||
|
||||
|
||||
VERBOSITY = 2
|
||||
FAILED_TESTS_FNAME = '.failed-tests.txt'
|
||||
NWORKERS = psutil.cpu_count() or 1
|
||||
USE_COLORS = not CI_TESTING and term_supports_colors()
|
||||
|
||||
HERE = os.path.abspath(os.path.dirname(__file__))
|
||||
loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase
|
||||
|
||||
|
||||
def cprint(msg, color, bold=False, file=None):
|
||||
if file is None:
|
||||
file = sys.stderr if color == 'red' else sys.stdout
|
||||
if USE_COLORS:
|
||||
print_color(msg, color, bold=bold, file=file)
|
||||
else:
|
||||
print(msg, file=file)
|
||||
|
||||
|
||||
class TestLoader:
|
||||
|
||||
testdir = HERE
|
||||
skip_files = ['test_memleaks.py']
|
||||
if "WHEELHOUSE_UPLOADER_USERNAME" in os.environ:
|
||||
skip_files.extend(['test_osx.py', 'test_linux.py', 'test_posix.py'])
|
||||
|
||||
def _get_testmods(self):
|
||||
return [os.path.join(self.testdir, x)
|
||||
for x in os.listdir(self.testdir)
|
||||
if x.startswith('test_') and x.endswith('.py') and
|
||||
x not in self.skip_files]
|
||||
|
||||
def _iter_testmod_classes(self):
|
||||
"""Iterate over all test files in this directory and return
|
||||
all TestCase classes in them.
|
||||
"""
|
||||
for path in self._get_testmods():
|
||||
mod = import_module_by_path(path)
|
||||
for name in dir(mod):
|
||||
obj = getattr(mod, name)
|
||||
if isinstance(obj, type) and \
|
||||
issubclass(obj, unittest.TestCase):
|
||||
yield obj
|
||||
|
||||
def all(self):
|
||||
suite = unittest.TestSuite()
|
||||
for obj in self._iter_testmod_classes():
|
||||
test = loadTestsFromTestCase(obj)
|
||||
suite.addTest(test)
|
||||
return suite
|
||||
|
||||
def last_failed(self):
|
||||
# ...from previously failed test run
|
||||
suite = unittest.TestSuite()
|
||||
if not os.path.isfile(FAILED_TESTS_FNAME):
|
||||
return suite
|
||||
with open(FAILED_TESTS_FNAME, 'rt') as f:
|
||||
names = f.read().split()
|
||||
for n in names:
|
||||
test = unittest.defaultTestLoader.loadTestsFromName(n)
|
||||
suite.addTest(test)
|
||||
return suite
|
||||
|
||||
def from_name(self, name):
|
||||
if name.endswith('.py'):
|
||||
name = os.path.splitext(os.path.basename(name))[0]
|
||||
return unittest.defaultTestLoader.loadTestsFromName(name)
|
||||
|
||||
|
||||
class ColouredResult(unittest.TextTestResult):
|
||||
|
||||
def addSuccess(self, test):
|
||||
unittest.TestResult.addSuccess(self, test)
|
||||
cprint("OK", "green")
|
||||
|
||||
def addError(self, test, err):
|
||||
unittest.TestResult.addError(self, test, err)
|
||||
cprint("ERROR", "red", bold=True)
|
||||
|
||||
def addFailure(self, test, err):
|
||||
unittest.TestResult.addFailure(self, test, err)
|
||||
cprint("FAIL", "red")
|
||||
|
||||
def addSkip(self, test, reason):
|
||||
unittest.TestResult.addSkip(self, test, reason)
|
||||
cprint("skipped: %s" % reason.strip(), "brown")
|
||||
|
||||
def printErrorList(self, flavour, errors):
|
||||
flavour = hilite(flavour, "red", bold=flavour == 'ERROR')
|
||||
super().printErrorList(flavour, errors)
|
||||
|
||||
|
||||
class ColouredTextRunner(unittest.TextTestRunner):
|
||||
"""
|
||||
A coloured text runner which also prints failed tests on KeyboardInterrupt
|
||||
and save failed tests in a file so that they can be re-run.
|
||||
"""
|
||||
resultclass = ColouredResult if USE_COLORS else unittest.TextTestResult
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
self.failed_tnames = set()
|
||||
|
||||
def _makeResult(self):
|
||||
# Store result instance so that it can be accessed on
|
||||
# KeyboardInterrupt.
|
||||
self.result = super()._makeResult()
|
||||
return self.result
|
||||
|
||||
def _write_last_failed(self):
|
||||
if self.failed_tnames:
|
||||
with open(FAILED_TESTS_FNAME, 'wt') as f:
|
||||
for tname in self.failed_tnames:
|
||||
f.write(tname + '\n')
|
||||
|
||||
def _save_result(self, result):
|
||||
if not result.wasSuccessful():
|
||||
for t in result.errors + result.failures:
|
||||
tname = t[0].id()
|
||||
self.failed_tnames.add(tname)
|
||||
|
||||
def _run(self, suite):
|
||||
try:
|
||||
result = super().run(suite)
|
||||
except (KeyboardInterrupt, SystemExit):
|
||||
result = self.runner.result
|
||||
result.printErrors()
|
||||
raise sys.exit(1)
|
||||
else:
|
||||
self._save_result(result)
|
||||
return result
|
||||
|
||||
def _exit(self, success):
|
||||
if success:
|
||||
cprint("SUCCESS", "green", bold=True)
|
||||
safe_rmpath(FAILED_TESTS_FNAME)
|
||||
sys.exit(0)
|
||||
else:
|
||||
cprint("FAILED", "red", bold=True)
|
||||
self._write_last_failed()
|
||||
sys.exit(1)
|
||||
|
||||
def run(self, suite):
|
||||
result = self._run(suite)
|
||||
self._exit(result.wasSuccessful())
|
||||
|
||||
|
||||
class ParallelRunner(ColouredTextRunner):
|
||||
|
||||
@staticmethod
|
||||
def _parallelize(suite):
|
||||
def fdopen(fd, mode, *kwds):
|
||||
stream = orig_fdopen(fd, mode)
|
||||
atexit.register(stream.close)
|
||||
return stream
|
||||
|
||||
# Monkey patch concurrencytest lib bug (fdopen() stream not closed).
|
||||
# https://github.com/cgoldberg/concurrencytest/issues/11
|
||||
orig_fdopen = os.fdopen
|
||||
concurrencytest.os.fdopen = fdopen
|
||||
forker = concurrencytest.fork_for_tests(NWORKERS)
|
||||
return concurrencytest.ConcurrentTestSuite(suite, forker)
|
||||
|
||||
@staticmethod
|
||||
def _split_suite(suite):
|
||||
serial = unittest.TestSuite()
|
||||
parallel = unittest.TestSuite()
|
||||
for test in suite:
|
||||
if test.countTestCases() == 0:
|
||||
continue
|
||||
elif isinstance(test, unittest.TestSuite):
|
||||
test_class = test._tests[0].__class__
|
||||
elif isinstance(test, unittest.TestCase):
|
||||
test_class = test
|
||||
else:
|
||||
raise TypeError("can't recognize type %r" % test)
|
||||
|
||||
if getattr(test_class, '_serialrun', False):
|
||||
serial.addTest(test)
|
||||
else:
|
||||
parallel.addTest(test)
|
||||
return (serial, parallel)
|
||||
|
||||
def run(self, suite):
|
||||
ser_suite, par_suite = self._split_suite(suite)
|
||||
par_suite = self._parallelize(par_suite)
|
||||
|
||||
# run parallel
|
||||
cprint("starting parallel tests using %s workers" % NWORKERS,
|
||||
"green", bold=True)
|
||||
t = time.time()
|
||||
par = self._run(par_suite)
|
||||
par_elapsed = time.time() - t
|
||||
|
||||
# At this point we should have N zombies (the workers), which
|
||||
# will disappear with wait().
|
||||
orphans = psutil.Process().children()
|
||||
gone, alive = psutil.wait_procs(orphans, timeout=1)
|
||||
if alive:
|
||||
cprint("alive processes %s" % alive, "red")
|
||||
reap_children()
|
||||
|
||||
# run serial
|
||||
t = time.time()
|
||||
ser = self._run(ser_suite)
|
||||
ser_elapsed = time.time() - t
|
||||
|
||||
# print
|
||||
if not par.wasSuccessful() and ser_suite.countTestCases() > 0:
|
||||
par.printErrors() # print them again at the bottom
|
||||
par_fails, par_errs, par_skips = map(len, (par.failures,
|
||||
par.errors,
|
||||
par.skipped))
|
||||
ser_fails, ser_errs, ser_skips = map(len, (ser.failures,
|
||||
ser.errors,
|
||||
ser.skipped))
|
||||
print(textwrap.dedent("""
|
||||
+----------+----------+----------+----------+----------+----------+
|
||||
| | total | failures | errors | skipped | time |
|
||||
+----------+----------+----------+----------+----------+----------+
|
||||
| parallel | %3s | %3s | %3s | %3s | %.2fs |
|
||||
+----------+----------+----------+----------+----------+----------+
|
||||
| serial | %3s | %3s | %3s | %3s | %.2fs |
|
||||
+----------+----------+----------+----------+----------+----------+
|
||||
""" % (par.testsRun, par_fails, par_errs, par_skips, par_elapsed,
|
||||
ser.testsRun, ser_fails, ser_errs, ser_skips, ser_elapsed)))
|
||||
print("Ran %s tests in %.3fs using %s workers" % (
|
||||
par.testsRun + ser.testsRun, par_elapsed + ser_elapsed, NWORKERS))
|
||||
ok = par.wasSuccessful() and ser.wasSuccessful()
|
||||
self._exit(ok)
|
||||
|
||||
|
||||
def get_runner(parallel=False):
|
||||
def warn(msg):
|
||||
cprint(msg + " Running serial tests instead.", "red")
|
||||
if parallel:
|
||||
if psutil.WINDOWS:
|
||||
warn("Can't run parallel tests on Windows.")
|
||||
elif concurrencytest is None:
|
||||
warn("concurrencytest module is not installed.")
|
||||
elif NWORKERS == 1:
|
||||
warn("Only 1 CPU available.")
|
||||
else:
|
||||
return ParallelRunner(verbosity=VERBOSITY)
|
||||
return ColouredTextRunner(verbosity=VERBOSITY)
|
||||
|
||||
|
||||
# Used by test_*,py modules.
|
||||
def run_from_name(name):
|
||||
if CI_TESTING:
|
||||
print_sysinfo()
|
||||
suite = TestLoader().from_name(name)
|
||||
runner = get_runner()
|
||||
runner.run(suite)
|
||||
|
||||
|
||||
def setup():
|
||||
psutil._set_debug(True)
|
||||
|
||||
|
||||
def main():
|
||||
setup()
|
||||
usage = "python3 -m psutil.tests [opts] [test-name]"
|
||||
parser = optparse.OptionParser(usage=usage, description="run unit tests")
|
||||
parser.add_option("--last-failed",
|
||||
action="store_true", default=False,
|
||||
help="only run last failed tests")
|
||||
parser.add_option("--parallel",
|
||||
action="store_true", default=False,
|
||||
help="run tests in parallel")
|
||||
opts, args = parser.parse_args()
|
||||
|
||||
if not opts.last_failed:
|
||||
safe_rmpath(FAILED_TESTS_FNAME)
|
||||
|
||||
# loader
|
||||
loader = TestLoader()
|
||||
if args:
|
||||
if len(args) > 1:
|
||||
parser.print_usage()
|
||||
return sys.exit(1)
|
||||
else:
|
||||
suite = loader.from_name(args[0])
|
||||
elif opts.last_failed:
|
||||
suite = loader.last_failed()
|
||||
else:
|
||||
suite = loader.all()
|
||||
|
||||
if CI_TESTING:
|
||||
print_sysinfo()
|
||||
runner = get_runner(opts.parallel)
|
||||
runner.run(suite)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
|
@ -0,0 +1,122 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# Copyright (c) 2009, Giampaolo Rodola'
|
||||
# Copyright (c) 2017, Arnon Yaari
|
||||
# All rights reserved.
|
||||
# Use of this source code is governed by a BSD-style license that can be
|
||||
# found in the LICENSE file.
|
||||
|
||||
"""AIX specific tests."""
|
||||
|
||||
import re
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
from psutil import AIX
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import sh
|
||||
|
||||
|
||||
@unittest.skipIf(not AIX, "AIX only")
|
||||
class AIXSpecificTestCase(PsutilTestCase):
|
||||
|
||||
def test_virtual_memory(self):
|
||||
out = sh('/usr/bin/svmon -O unit=KB')
|
||||
re_pattern = r"memory\s*"
|
||||
for field in ("size inuse free pin virtual available mmode").split():
|
||||
re_pattern += r"(?P<%s>\S+)\s+" % (field,)
|
||||
matchobj = re.search(re_pattern, out)
|
||||
|
||||
self.assertIsNotNone(
|
||||
matchobj, "svmon command returned unexpected output")
|
||||
|
||||
KB = 1024
|
||||
total = int(matchobj.group("size")) * KB
|
||||
available = int(matchobj.group("available")) * KB
|
||||
used = int(matchobj.group("inuse")) * KB
|
||||
free = int(matchobj.group("free")) * KB
|
||||
|
||||
psutil_result = psutil.virtual_memory()
|
||||
|
||||
# TOLERANCE_SYS_MEM from psutil.tests is not enough. For some reason
|
||||
# we're seeing differences of ~1.2 MB. 2 MB is still a good tolerance
|
||||
# when compared to GBs.
|
||||
TOLERANCE_SYS_MEM = 2 * KB * KB # 2 MB
|
||||
self.assertEqual(psutil_result.total, total)
|
||||
self.assertAlmostEqual(
|
||||
psutil_result.used, used, delta=TOLERANCE_SYS_MEM)
|
||||
self.assertAlmostEqual(
|
||||
psutil_result.available, available, delta=TOLERANCE_SYS_MEM)
|
||||
self.assertAlmostEqual(
|
||||
psutil_result.free, free, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_swap_memory(self):
|
||||
out = sh('/usr/sbin/lsps -a')
|
||||
# From the man page, "The size is given in megabytes" so we assume
|
||||
# we'll always have 'MB' in the result
|
||||
# TODO maybe try to use "swap -l" to check "used" too, but its units
|
||||
# are not guaranteed to be "MB" so parsing may not be consistent
|
||||
matchobj = re.search(r"(?P<space>\S+)\s+"
|
||||
r"(?P<vol>\S+)\s+"
|
||||
r"(?P<vg>\S+)\s+"
|
||||
r"(?P<size>\d+)MB", out)
|
||||
|
||||
self.assertIsNotNone(
|
||||
matchobj, "lsps command returned unexpected output")
|
||||
|
||||
total_mb = int(matchobj.group("size"))
|
||||
MB = 1024 ** 2
|
||||
psutil_result = psutil.swap_memory()
|
||||
# we divide our result by MB instead of multiplying the lsps value by
|
||||
# MB because lsps may round down, so we round down too
|
||||
self.assertEqual(int(psutil_result.total / MB), total_mb)
|
||||
|
||||
def test_cpu_stats(self):
|
||||
out = sh('/usr/bin/mpstat -a')
|
||||
|
||||
re_pattern = r"ALL\s*"
|
||||
for field in ("min maj mpcs mpcr dev soft dec ph cs ics bound rq "
|
||||
"push S3pull S3grd S0rd S1rd S2rd S3rd S4rd S5rd "
|
||||
"sysc").split():
|
||||
re_pattern += r"(?P<%s>\S+)\s+" % (field,)
|
||||
matchobj = re.search(re_pattern, out)
|
||||
|
||||
self.assertIsNotNone(
|
||||
matchobj, "mpstat command returned unexpected output")
|
||||
|
||||
# numbers are usually in the millions so 1000 is ok for tolerance
|
||||
CPU_STATS_TOLERANCE = 1000
|
||||
psutil_result = psutil.cpu_stats()
|
||||
self.assertAlmostEqual(
|
||||
psutil_result.ctx_switches,
|
||||
int(matchobj.group("cs")),
|
||||
delta=CPU_STATS_TOLERANCE)
|
||||
self.assertAlmostEqual(
|
||||
psutil_result.syscalls,
|
||||
int(matchobj.group("sysc")),
|
||||
delta=CPU_STATS_TOLERANCE)
|
||||
self.assertAlmostEqual(
|
||||
psutil_result.interrupts,
|
||||
int(matchobj.group("dev")),
|
||||
delta=CPU_STATS_TOLERANCE)
|
||||
self.assertAlmostEqual(
|
||||
psutil_result.soft_interrupts,
|
||||
int(matchobj.group("soft")),
|
||||
delta=CPU_STATS_TOLERANCE)
|
||||
|
||||
def test_cpu_count_logical(self):
|
||||
out = sh('/usr/bin/mpstat -a')
|
||||
mpstat_lcpu = int(re.search(r"lcpu=(\d+)", out).group(1))
|
||||
psutil_lcpu = psutil.cpu_count(logical=True)
|
||||
self.assertEqual(mpstat_lcpu, psutil_lcpu)
|
||||
|
||||
def test_net_if_addrs_names(self):
|
||||
out = sh('/etc/ifconfig -l')
|
||||
ifconfig_names = set(out.split())
|
||||
psutil_names = set(psutil.net_if_addrs().keys())
|
||||
self.assertSetEqual(ifconfig_names, psutil_names)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,581 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
# TODO: (FreeBSD) add test for comparing connections with 'sockstat' cmd.
|
||||
|
||||
|
||||
"""Tests specific to all BSD platforms."""
|
||||
|
||||
|
||||
import datetime
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
from psutil import BSD
|
||||
from psutil import FREEBSD
|
||||
from psutil import NETBSD
|
||||
from psutil import OPENBSD
|
||||
from psutil.tests import HAS_BATTERY
|
||||
from psutil.tests import TOLERANCE_SYS_MEM
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import retry_on_failure
|
||||
from psutil.tests import sh
|
||||
from psutil.tests import spawn_testproc
|
||||
from psutil.tests import terminate
|
||||
from psutil.tests import which
|
||||
|
||||
|
||||
if BSD:
|
||||
from psutil._psutil_posix import getpagesize
|
||||
|
||||
PAGESIZE = getpagesize()
|
||||
# muse requires root privileges
|
||||
MUSE_AVAILABLE = os.getuid() == 0 and which('muse')
|
||||
else:
|
||||
PAGESIZE = None
|
||||
MUSE_AVAILABLE = False
|
||||
|
||||
|
||||
def sysctl(cmdline):
|
||||
"""Expects a sysctl command with an argument and parse the result
|
||||
returning only the value of interest.
|
||||
"""
|
||||
result = sh("sysctl " + cmdline)
|
||||
if FREEBSD:
|
||||
result = result[result.find(": ") + 2:]
|
||||
elif OPENBSD or NETBSD:
|
||||
result = result[result.find("=") + 1:]
|
||||
try:
|
||||
return int(result)
|
||||
except ValueError:
|
||||
return result
|
||||
|
||||
|
||||
def muse(field):
|
||||
"""Thin wrapper around 'muse' cmdline utility."""
|
||||
out = sh('muse')
|
||||
for line in out.split('\n'):
|
||||
if line.startswith(field):
|
||||
break
|
||||
else:
|
||||
raise ValueError("line not found")
|
||||
return int(line.split()[1])
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- All BSD*
|
||||
# =====================================================================
|
||||
|
||||
|
||||
@unittest.skipIf(not BSD, "BSD only")
|
||||
class BSDTestCase(PsutilTestCase):
|
||||
"""Generic tests common to all BSD variants."""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.pid = spawn_testproc().pid
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
terminate(cls.pid)
|
||||
|
||||
@unittest.skipIf(NETBSD, "-o lstart doesn't work on NETBSD")
|
||||
def test_process_create_time(self):
|
||||
output = sh("ps -o lstart -p %s" % self.pid)
|
||||
start_ps = output.replace('STARTED', '').strip()
|
||||
start_psutil = psutil.Process(self.pid).create_time()
|
||||
start_psutil = time.strftime("%a %b %e %H:%M:%S %Y",
|
||||
time.localtime(start_psutil))
|
||||
self.assertEqual(start_ps, start_psutil)
|
||||
|
||||
def test_disks(self):
|
||||
# test psutil.disk_usage() and psutil.disk_partitions()
|
||||
# against "df -a"
|
||||
def df(path):
|
||||
out = sh('df -k "%s"' % path).strip()
|
||||
lines = out.split('\n')
|
||||
lines.pop(0)
|
||||
line = lines.pop(0)
|
||||
dev, total, used, free = line.split()[:4]
|
||||
if dev == 'none':
|
||||
dev = ''
|
||||
total = int(total) * 1024
|
||||
used = int(used) * 1024
|
||||
free = int(free) * 1024
|
||||
return dev, total, used, free
|
||||
|
||||
for part in psutil.disk_partitions(all=False):
|
||||
usage = psutil.disk_usage(part.mountpoint)
|
||||
dev, total, used, free = df(part.mountpoint)
|
||||
self.assertEqual(part.device, dev)
|
||||
self.assertEqual(usage.total, total)
|
||||
# 10 MB tolerance
|
||||
if abs(usage.free - free) > 10 * 1024 * 1024:
|
||||
raise self.fail("psutil=%s, df=%s" % (usage.free, free))
|
||||
if abs(usage.used - used) > 10 * 1024 * 1024:
|
||||
raise self.fail("psutil=%s, df=%s" % (usage.used, used))
|
||||
|
||||
@unittest.skipIf(not which('sysctl'), "sysctl cmd not available")
|
||||
def test_cpu_count_logical(self):
|
||||
syst = sysctl("hw.ncpu")
|
||||
self.assertEqual(psutil.cpu_count(logical=True), syst)
|
||||
|
||||
@unittest.skipIf(not which('sysctl'), "sysctl cmd not available")
|
||||
@unittest.skipIf(NETBSD, "skipped on NETBSD") # we check /proc/meminfo
|
||||
def test_virtual_memory_total(self):
|
||||
num = sysctl('hw.physmem')
|
||||
self.assertEqual(num, psutil.virtual_memory().total)
|
||||
|
||||
@unittest.skipIf(not which('ifconfig'), "ifconfig cmd not available")
|
||||
def test_net_if_stats(self):
|
||||
for name, stats in psutil.net_if_stats().items():
|
||||
try:
|
||||
out = sh("ifconfig %s" % name)
|
||||
except RuntimeError:
|
||||
pass
|
||||
else:
|
||||
self.assertEqual(stats.isup, 'RUNNING' in out, msg=out)
|
||||
if "mtu" in out:
|
||||
self.assertEqual(stats.mtu,
|
||||
int(re.findall(r'mtu (\d+)', out)[0]))
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- FreeBSD
|
||||
# =====================================================================
|
||||
|
||||
|
||||
@unittest.skipIf(not FREEBSD, "FREEBSD only")
|
||||
class FreeBSDPsutilTestCase(PsutilTestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.pid = spawn_testproc().pid
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
terminate(cls.pid)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_memory_maps(self):
|
||||
out = sh('procstat -v %s' % self.pid)
|
||||
maps = psutil.Process(self.pid).memory_maps(grouped=False)
|
||||
lines = out.split('\n')[1:]
|
||||
while lines:
|
||||
line = lines.pop()
|
||||
fields = line.split()
|
||||
_, start, stop, perms, res = fields[:5]
|
||||
map = maps.pop()
|
||||
self.assertEqual("%s-%s" % (start, stop), map.addr)
|
||||
self.assertEqual(int(res), map.rss)
|
||||
if not map.path.startswith('['):
|
||||
self.assertEqual(fields[10], map.path)
|
||||
|
||||
def test_exe(self):
|
||||
out = sh('procstat -b %s' % self.pid)
|
||||
self.assertEqual(psutil.Process(self.pid).exe(),
|
||||
out.split('\n')[1].split()[-1])
|
||||
|
||||
def test_cmdline(self):
|
||||
out = sh('procstat -c %s' % self.pid)
|
||||
self.assertEqual(' '.join(psutil.Process(self.pid).cmdline()),
|
||||
' '.join(out.split('\n')[1].split()[2:]))
|
||||
|
||||
def test_uids_gids(self):
|
||||
out = sh('procstat -s %s' % self.pid)
|
||||
euid, ruid, suid, egid, rgid, sgid = out.split('\n')[1].split()[2:8]
|
||||
p = psutil.Process(self.pid)
|
||||
uids = p.uids()
|
||||
gids = p.gids()
|
||||
self.assertEqual(uids.real, int(ruid))
|
||||
self.assertEqual(uids.effective, int(euid))
|
||||
self.assertEqual(uids.saved, int(suid))
|
||||
self.assertEqual(gids.real, int(rgid))
|
||||
self.assertEqual(gids.effective, int(egid))
|
||||
self.assertEqual(gids.saved, int(sgid))
|
||||
|
||||
@retry_on_failure()
|
||||
def test_ctx_switches(self):
|
||||
tested = []
|
||||
out = sh('procstat -r %s' % self.pid)
|
||||
p = psutil.Process(self.pid)
|
||||
for line in out.split('\n'):
|
||||
line = line.lower().strip()
|
||||
if ' voluntary context' in line:
|
||||
pstat_value = int(line.split()[-1])
|
||||
psutil_value = p.num_ctx_switches().voluntary
|
||||
self.assertEqual(pstat_value, psutil_value)
|
||||
tested.append(None)
|
||||
elif ' involuntary context' in line:
|
||||
pstat_value = int(line.split()[-1])
|
||||
psutil_value = p.num_ctx_switches().involuntary
|
||||
self.assertEqual(pstat_value, psutil_value)
|
||||
tested.append(None)
|
||||
if len(tested) != 2:
|
||||
raise RuntimeError("couldn't find lines match in procstat out")
|
||||
|
||||
@retry_on_failure()
|
||||
def test_cpu_times(self):
|
||||
tested = []
|
||||
out = sh('procstat -r %s' % self.pid)
|
||||
p = psutil.Process(self.pid)
|
||||
for line in out.split('\n'):
|
||||
line = line.lower().strip()
|
||||
if 'user time' in line:
|
||||
pstat_value = float('0.' + line.split()[-1].split('.')[-1])
|
||||
psutil_value = p.cpu_times().user
|
||||
self.assertEqual(pstat_value, psutil_value)
|
||||
tested.append(None)
|
||||
elif 'system time' in line:
|
||||
pstat_value = float('0.' + line.split()[-1].split('.')[-1])
|
||||
psutil_value = p.cpu_times().system
|
||||
self.assertEqual(pstat_value, psutil_value)
|
||||
tested.append(None)
|
||||
if len(tested) != 2:
|
||||
raise RuntimeError("couldn't find lines match in procstat out")
|
||||
|
||||
|
||||
@unittest.skipIf(not FREEBSD, "FREEBSD only")
|
||||
class FreeBSDSystemTestCase(PsutilTestCase):
|
||||
|
||||
@staticmethod
|
||||
def parse_swapinfo():
|
||||
# the last line is always the total
|
||||
output = sh("swapinfo -k").splitlines()[-1]
|
||||
parts = re.split(r'\s+', output)
|
||||
|
||||
if not parts:
|
||||
raise ValueError("Can't parse swapinfo: %s" % output)
|
||||
|
||||
# the size is in 1k units, so multiply by 1024
|
||||
total, used, free = (int(p) * 1024 for p in parts[1:4])
|
||||
return total, used, free
|
||||
|
||||
def test_cpu_frequency_against_sysctl(self):
|
||||
# Currently only cpu 0 is frequency is supported in FreeBSD
|
||||
# All other cores use the same frequency.
|
||||
sensor = "dev.cpu.0.freq"
|
||||
try:
|
||||
sysctl_result = int(sysctl(sensor))
|
||||
except RuntimeError:
|
||||
self.skipTest("frequencies not supported by kernel")
|
||||
self.assertEqual(psutil.cpu_freq().current, sysctl_result)
|
||||
|
||||
sensor = "dev.cpu.0.freq_levels"
|
||||
sysctl_result = sysctl(sensor)
|
||||
# sysctl returns a string of the format:
|
||||
# <freq_level_1>/<voltage_level_1> <freq_level_2>/<voltage_level_2>...
|
||||
# Ordered highest available to lowest available.
|
||||
max_freq = int(sysctl_result.split()[0].split("/")[0])
|
||||
min_freq = int(sysctl_result.split()[-1].split("/")[0])
|
||||
self.assertEqual(psutil.cpu_freq().max, max_freq)
|
||||
self.assertEqual(psutil.cpu_freq().min, min_freq)
|
||||
|
||||
# --- virtual_memory(); tests against sysctl
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_active(self):
|
||||
syst = sysctl("vm.stats.vm.v_active_count") * PAGESIZE
|
||||
self.assertAlmostEqual(psutil.virtual_memory().active, syst,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_inactive(self):
|
||||
syst = sysctl("vm.stats.vm.v_inactive_count") * PAGESIZE
|
||||
self.assertAlmostEqual(psutil.virtual_memory().inactive, syst,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_wired(self):
|
||||
syst = sysctl("vm.stats.vm.v_wire_count") * PAGESIZE
|
||||
self.assertAlmostEqual(psutil.virtual_memory().wired, syst,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_cached(self):
|
||||
syst = sysctl("vm.stats.vm.v_cache_count") * PAGESIZE
|
||||
self.assertAlmostEqual(psutil.virtual_memory().cached, syst,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_free(self):
|
||||
syst = sysctl("vm.stats.vm.v_free_count") * PAGESIZE
|
||||
self.assertAlmostEqual(psutil.virtual_memory().free, syst,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_buffers(self):
|
||||
syst = sysctl("vfs.bufspace")
|
||||
self.assertAlmostEqual(psutil.virtual_memory().buffers, syst,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
# --- virtual_memory(); tests against muse
|
||||
|
||||
@unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
|
||||
def test_muse_vmem_total(self):
|
||||
num = muse('Total')
|
||||
self.assertEqual(psutil.virtual_memory().total, num)
|
||||
|
||||
@unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
|
||||
@retry_on_failure()
|
||||
def test_muse_vmem_active(self):
|
||||
num = muse('Active')
|
||||
self.assertAlmostEqual(psutil.virtual_memory().active, num,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
|
||||
@retry_on_failure()
|
||||
def test_muse_vmem_inactive(self):
|
||||
num = muse('Inactive')
|
||||
self.assertAlmostEqual(psutil.virtual_memory().inactive, num,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
|
||||
@retry_on_failure()
|
||||
def test_muse_vmem_wired(self):
|
||||
num = muse('Wired')
|
||||
self.assertAlmostEqual(psutil.virtual_memory().wired, num,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
|
||||
@retry_on_failure()
|
||||
def test_muse_vmem_cached(self):
|
||||
num = muse('Cache')
|
||||
self.assertAlmostEqual(psutil.virtual_memory().cached, num,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
|
||||
@retry_on_failure()
|
||||
def test_muse_vmem_free(self):
|
||||
num = muse('Free')
|
||||
self.assertAlmostEqual(psutil.virtual_memory().free, num,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
|
||||
@retry_on_failure()
|
||||
def test_muse_vmem_buffers(self):
|
||||
num = muse('Buffer')
|
||||
self.assertAlmostEqual(psutil.virtual_memory().buffers, num,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_cpu_stats_ctx_switches(self):
|
||||
self.assertAlmostEqual(psutil.cpu_stats().ctx_switches,
|
||||
sysctl('vm.stats.sys.v_swtch'), delta=1000)
|
||||
|
||||
def test_cpu_stats_interrupts(self):
|
||||
self.assertAlmostEqual(psutil.cpu_stats().interrupts,
|
||||
sysctl('vm.stats.sys.v_intr'), delta=1000)
|
||||
|
||||
def test_cpu_stats_soft_interrupts(self):
|
||||
self.assertAlmostEqual(psutil.cpu_stats().soft_interrupts,
|
||||
sysctl('vm.stats.sys.v_soft'), delta=1000)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_cpu_stats_syscalls(self):
|
||||
# pretty high tolerance but it looks like it's OK.
|
||||
self.assertAlmostEqual(psutil.cpu_stats().syscalls,
|
||||
sysctl('vm.stats.sys.v_syscall'), delta=200000)
|
||||
|
||||
# def test_cpu_stats_traps(self):
|
||||
# self.assertAlmostEqual(psutil.cpu_stats().traps,
|
||||
# sysctl('vm.stats.sys.v_trap'), delta=1000)
|
||||
|
||||
# --- swap memory
|
||||
|
||||
def test_swapmem_free(self):
|
||||
total, used, free = self.parse_swapinfo()
|
||||
self.assertAlmostEqual(
|
||||
psutil.swap_memory().free, free, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_swapmem_used(self):
|
||||
total, used, free = self.parse_swapinfo()
|
||||
self.assertAlmostEqual(
|
||||
psutil.swap_memory().used, used, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_swapmem_total(self):
|
||||
total, used, free = self.parse_swapinfo()
|
||||
self.assertAlmostEqual(
|
||||
psutil.swap_memory().total, total, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
# --- others
|
||||
|
||||
def test_boot_time(self):
|
||||
s = sysctl('sysctl kern.boottime')
|
||||
s = s[s.find(" sec = ") + 7:]
|
||||
s = s[:s.find(',')]
|
||||
btime = int(s)
|
||||
self.assertEqual(btime, psutil.boot_time())
|
||||
|
||||
# --- sensors_battery
|
||||
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_sensors_battery(self):
|
||||
def secs2hours(secs):
|
||||
m, s = divmod(secs, 60)
|
||||
h, m = divmod(m, 60)
|
||||
return "%d:%02d" % (h, m)
|
||||
|
||||
out = sh("acpiconf -i 0")
|
||||
fields = dict([(x.split('\t')[0], x.split('\t')[-1])
|
||||
for x in out.split("\n")])
|
||||
metrics = psutil.sensors_battery()
|
||||
percent = int(fields['Remaining capacity:'].replace('%', ''))
|
||||
remaining_time = fields['Remaining time:']
|
||||
self.assertEqual(metrics.percent, percent)
|
||||
if remaining_time == 'unknown':
|
||||
self.assertEqual(metrics.secsleft, psutil.POWER_TIME_UNLIMITED)
|
||||
else:
|
||||
self.assertEqual(secs2hours(metrics.secsleft), remaining_time)
|
||||
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_sensors_battery_against_sysctl(self):
|
||||
self.assertEqual(psutil.sensors_battery().percent,
|
||||
sysctl("hw.acpi.battery.life"))
|
||||
self.assertEqual(psutil.sensors_battery().power_plugged,
|
||||
sysctl("hw.acpi.acline") == 1)
|
||||
secsleft = psutil.sensors_battery().secsleft
|
||||
if secsleft < 0:
|
||||
self.assertEqual(sysctl("hw.acpi.battery.time"), -1)
|
||||
else:
|
||||
self.assertEqual(secsleft, sysctl("hw.acpi.battery.time") * 60)
|
||||
|
||||
@unittest.skipIf(HAS_BATTERY, "has battery")
|
||||
def test_sensors_battery_no_battery(self):
|
||||
# If no battery is present one of these calls is supposed
|
||||
# to fail, see:
|
||||
# https://github.com/giampaolo/psutil/issues/1074
|
||||
with self.assertRaises(RuntimeError):
|
||||
sysctl("hw.acpi.battery.life")
|
||||
sysctl("hw.acpi.battery.time")
|
||||
sysctl("hw.acpi.acline")
|
||||
self.assertIsNone(psutil.sensors_battery())
|
||||
|
||||
# --- sensors_temperatures
|
||||
|
||||
def test_sensors_temperatures_against_sysctl(self):
|
||||
num_cpus = psutil.cpu_count(True)
|
||||
for cpu in range(num_cpus):
|
||||
sensor = "dev.cpu.%s.temperature" % cpu
|
||||
# sysctl returns a string in the format 46.0C
|
||||
try:
|
||||
sysctl_result = int(float(sysctl(sensor)[:-1]))
|
||||
except RuntimeError:
|
||||
self.skipTest("temperatures not supported by kernel")
|
||||
self.assertAlmostEqual(
|
||||
psutil.sensors_temperatures()["coretemp"][cpu].current,
|
||||
sysctl_result, delta=10)
|
||||
|
||||
sensor = "dev.cpu.%s.coretemp.tjmax" % cpu
|
||||
sysctl_result = int(float(sysctl(sensor)[:-1]))
|
||||
self.assertEqual(
|
||||
psutil.sensors_temperatures()["coretemp"][cpu].high,
|
||||
sysctl_result)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- OpenBSD
|
||||
# =====================================================================
|
||||
|
||||
|
||||
@unittest.skipIf(not OPENBSD, "OPENBSD only")
|
||||
class OpenBSDTestCase(PsutilTestCase):
|
||||
|
||||
def test_boot_time(self):
|
||||
s = sysctl('kern.boottime')
|
||||
sys_bt = datetime.datetime.strptime(s, "%a %b %d %H:%M:%S %Y")
|
||||
psutil_bt = datetime.datetime.fromtimestamp(psutil.boot_time())
|
||||
self.assertEqual(sys_bt, psutil_bt)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# --- NetBSD
|
||||
# =====================================================================
|
||||
|
||||
|
||||
@unittest.skipIf(not NETBSD, "NETBSD only")
|
||||
class NetBSDTestCase(PsutilTestCase):
|
||||
|
||||
@staticmethod
|
||||
def parse_meminfo(look_for):
|
||||
with open('/proc/meminfo', 'rt') as f:
|
||||
for line in f:
|
||||
if line.startswith(look_for):
|
||||
return int(line.split()[1]) * 1024
|
||||
raise ValueError("can't find %s" % look_for)
|
||||
|
||||
# --- virtual mem
|
||||
|
||||
def test_vmem_total(self):
|
||||
self.assertEqual(
|
||||
psutil.virtual_memory().total, self.parse_meminfo("MemTotal:"))
|
||||
|
||||
def test_vmem_free(self):
|
||||
self.assertAlmostEqual(
|
||||
psutil.virtual_memory().free, self.parse_meminfo("MemFree:"),
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_vmem_buffers(self):
|
||||
self.assertAlmostEqual(
|
||||
psutil.virtual_memory().buffers, self.parse_meminfo("Buffers:"),
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_vmem_shared(self):
|
||||
self.assertAlmostEqual(
|
||||
psutil.virtual_memory().shared, self.parse_meminfo("MemShared:"),
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_vmem_cached(self):
|
||||
self.assertAlmostEqual(
|
||||
psutil.virtual_memory().cached, self.parse_meminfo("Cached:"),
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
# --- swap mem
|
||||
|
||||
def test_swapmem_total(self):
|
||||
self.assertAlmostEqual(
|
||||
psutil.swap_memory().total, self.parse_meminfo("SwapTotal:"),
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_swapmem_free(self):
|
||||
self.assertAlmostEqual(
|
||||
psutil.swap_memory().free, self.parse_meminfo("SwapFree:"),
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_swapmem_used(self):
|
||||
smem = psutil.swap_memory()
|
||||
self.assertEqual(smem.used, smem.total - smem.free)
|
||||
|
||||
# --- others
|
||||
|
||||
def test_cpu_stats_interrupts(self):
|
||||
with open('/proc/stat', 'rb') as f:
|
||||
for line in f:
|
||||
if line.startswith(b'intr'):
|
||||
interrupts = int(line.split()[1])
|
||||
break
|
||||
else:
|
||||
raise ValueError("couldn't find line")
|
||||
self.assertAlmostEqual(
|
||||
psutil.cpu_stats().interrupts, interrupts, delta=1000)
|
||||
|
||||
def test_cpu_stats_ctx_switches(self):
|
||||
with open('/proc/stat', 'rb') as f:
|
||||
for line in f:
|
||||
if line.startswith(b'ctxt'):
|
||||
ctx_switches = int(line.split()[1])
|
||||
break
|
||||
else:
|
||||
raise ValueError("couldn't find line")
|
||||
self.assertAlmostEqual(
|
||||
psutil.cpu_stats().ctx_switches, ctx_switches, delta=1000)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,544 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""Tests for net_connections() and Process.connections() APIs."""
|
||||
|
||||
import os
|
||||
import socket
|
||||
import textwrap
|
||||
import unittest
|
||||
from contextlib import closing
|
||||
from socket import AF_INET
|
||||
from socket import AF_INET6
|
||||
from socket import SOCK_DGRAM
|
||||
from socket import SOCK_STREAM
|
||||
|
||||
import psutil
|
||||
from psutil import FREEBSD
|
||||
from psutil import LINUX
|
||||
from psutil import MACOS
|
||||
from psutil import NETBSD
|
||||
from psutil import OPENBSD
|
||||
from psutil import POSIX
|
||||
from psutil import SUNOS
|
||||
from psutil import WINDOWS
|
||||
from psutil._common import supports_ipv6
|
||||
from psutil._compat import PY3
|
||||
from psutil.tests import AF_UNIX
|
||||
from psutil.tests import HAS_CONNECTIONS_UNIX
|
||||
from psutil.tests import SKIP_SYSCONS
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import bind_socket
|
||||
from psutil.tests import bind_unix_socket
|
||||
from psutil.tests import check_connection_ntuple
|
||||
from psutil.tests import create_sockets
|
||||
from psutil.tests import reap_children
|
||||
from psutil.tests import retry_on_failure
|
||||
from psutil.tests import serialrun
|
||||
from psutil.tests import skip_on_access_denied
|
||||
from psutil.tests import tcp_socketpair
|
||||
from psutil.tests import unix_socketpair
|
||||
from psutil.tests import wait_for_file
|
||||
|
||||
|
||||
thisproc = psutil.Process()
|
||||
SOCK_SEQPACKET = getattr(socket, "SOCK_SEQPACKET", object())
|
||||
|
||||
|
||||
@serialrun
|
||||
class ConnectionTestCase(PsutilTestCase):
|
||||
|
||||
def setUp(self):
|
||||
if not (NETBSD or FREEBSD):
|
||||
# process opens a UNIX socket to /var/log/run.
|
||||
cons = thisproc.connections(kind='all')
|
||||
assert not cons, cons
|
||||
|
||||
def tearDown(self):
|
||||
if not (FREEBSD or NETBSD):
|
||||
# Make sure we closed all resources.
|
||||
# NetBSD opens a UNIX socket to /var/log/run.
|
||||
cons = thisproc.connections(kind='all')
|
||||
assert not cons, cons
|
||||
|
||||
def compare_procsys_connections(self, pid, proc_cons, kind='all'):
|
||||
"""Given a process PID and its list of connections compare
|
||||
those against system-wide connections retrieved via
|
||||
psutil.net_connections.
|
||||
"""
|
||||
try:
|
||||
sys_cons = psutil.net_connections(kind=kind)
|
||||
except psutil.AccessDenied:
|
||||
# On MACOS, system-wide connections are retrieved by iterating
|
||||
# over all processes
|
||||
if MACOS:
|
||||
return
|
||||
else:
|
||||
raise
|
||||
# Filter for this proc PID and exlucde PIDs from the tuple.
|
||||
sys_cons = [c[:-1] for c in sys_cons if c.pid == pid]
|
||||
sys_cons.sort()
|
||||
proc_cons.sort()
|
||||
self.assertEqual(proc_cons, sys_cons)
|
||||
|
||||
|
||||
class TestBasicOperations(ConnectionTestCase):
|
||||
|
||||
@unittest.skipIf(SKIP_SYSCONS, "requires root")
|
||||
def test_system(self):
|
||||
with create_sockets():
|
||||
for conn in psutil.net_connections(kind='all'):
|
||||
check_connection_ntuple(conn)
|
||||
|
||||
def test_process(self):
|
||||
with create_sockets():
|
||||
for conn in psutil.Process().connections(kind='all'):
|
||||
check_connection_ntuple(conn)
|
||||
|
||||
def test_invalid_kind(self):
|
||||
self.assertRaises(ValueError, thisproc.connections, kind='???')
|
||||
self.assertRaises(ValueError, psutil.net_connections, kind='???')
|
||||
|
||||
|
||||
@serialrun
|
||||
class TestUnconnectedSockets(ConnectionTestCase):
|
||||
"""Tests sockets which are open but not connected to anything."""
|
||||
|
||||
def get_conn_from_sock(self, sock):
|
||||
cons = thisproc.connections(kind='all')
|
||||
smap = dict([(c.fd, c) for c in cons])
|
||||
if NETBSD or FREEBSD:
|
||||
# NetBSD opens a UNIX socket to /var/log/run
|
||||
# so there may be more connections.
|
||||
return smap[sock.fileno()]
|
||||
else:
|
||||
self.assertEqual(len(cons), 1)
|
||||
if cons[0].fd != -1:
|
||||
self.assertEqual(smap[sock.fileno()].fd, sock.fileno())
|
||||
return cons[0]
|
||||
|
||||
def check_socket(self, sock):
|
||||
"""Given a socket, makes sure it matches the one obtained
|
||||
via psutil. It assumes this process created one connection
|
||||
only (the one supposed to be checked).
|
||||
"""
|
||||
conn = self.get_conn_from_sock(sock)
|
||||
check_connection_ntuple(conn)
|
||||
|
||||
# fd, family, type
|
||||
if conn.fd != -1:
|
||||
self.assertEqual(conn.fd, sock.fileno())
|
||||
self.assertEqual(conn.family, sock.family)
|
||||
# see: http://bugs.python.org/issue30204
|
||||
self.assertEqual(
|
||||
conn.type, sock.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE))
|
||||
|
||||
# local address
|
||||
laddr = sock.getsockname()
|
||||
if not laddr and PY3 and isinstance(laddr, bytes):
|
||||
# See: http://bugs.python.org/issue30205
|
||||
laddr = laddr.decode()
|
||||
if sock.family == AF_INET6:
|
||||
laddr = laddr[:2]
|
||||
self.assertEqual(conn.laddr, laddr)
|
||||
|
||||
# XXX Solaris can't retrieve system-wide UNIX sockets
|
||||
if sock.family == AF_UNIX and HAS_CONNECTIONS_UNIX:
|
||||
cons = thisproc.connections(kind='all')
|
||||
self.compare_procsys_connections(os.getpid(), cons, kind='all')
|
||||
return conn
|
||||
|
||||
def test_tcp_v4(self):
|
||||
addr = ("127.0.0.1", 0)
|
||||
with closing(bind_socket(AF_INET, SOCK_STREAM, addr=addr)) as sock:
|
||||
conn = self.check_socket(sock)
|
||||
assert not conn.raddr
|
||||
self.assertEqual(conn.status, psutil.CONN_LISTEN)
|
||||
|
||||
@unittest.skipIf(not supports_ipv6(), "IPv6 not supported")
|
||||
def test_tcp_v6(self):
|
||||
addr = ("::1", 0)
|
||||
with closing(bind_socket(AF_INET6, SOCK_STREAM, addr=addr)) as sock:
|
||||
conn = self.check_socket(sock)
|
||||
assert not conn.raddr
|
||||
self.assertEqual(conn.status, psutil.CONN_LISTEN)
|
||||
|
||||
def test_udp_v4(self):
|
||||
addr = ("127.0.0.1", 0)
|
||||
with closing(bind_socket(AF_INET, SOCK_DGRAM, addr=addr)) as sock:
|
||||
conn = self.check_socket(sock)
|
||||
assert not conn.raddr
|
||||
self.assertEqual(conn.status, psutil.CONN_NONE)
|
||||
|
||||
@unittest.skipIf(not supports_ipv6(), "IPv6 not supported")
|
||||
def test_udp_v6(self):
|
||||
addr = ("::1", 0)
|
||||
with closing(bind_socket(AF_INET6, SOCK_DGRAM, addr=addr)) as sock:
|
||||
conn = self.check_socket(sock)
|
||||
assert not conn.raddr
|
||||
self.assertEqual(conn.status, psutil.CONN_NONE)
|
||||
|
||||
@unittest.skipIf(not POSIX, 'POSIX only')
|
||||
def test_unix_tcp(self):
|
||||
testfn = self.get_testfn()
|
||||
with closing(bind_unix_socket(testfn, type=SOCK_STREAM)) as sock:
|
||||
conn = self.check_socket(sock)
|
||||
assert not conn.raddr
|
||||
self.assertEqual(conn.status, psutil.CONN_NONE)
|
||||
|
||||
@unittest.skipIf(not POSIX, 'POSIX only')
|
||||
def test_unix_udp(self):
|
||||
testfn = self.get_testfn()
|
||||
with closing(bind_unix_socket(testfn, type=SOCK_STREAM)) as sock:
|
||||
conn = self.check_socket(sock)
|
||||
assert not conn.raddr
|
||||
self.assertEqual(conn.status, psutil.CONN_NONE)
|
||||
|
||||
|
||||
@serialrun
|
||||
class TestConnectedSocket(ConnectionTestCase):
|
||||
"""Test socket pairs which are are actually connected to
|
||||
each other.
|
||||
"""
|
||||
|
||||
# On SunOS, even after we close() it, the server socket stays around
|
||||
# in TIME_WAIT state.
|
||||
@unittest.skipIf(SUNOS, "unreliable on SUONS")
|
||||
def test_tcp(self):
|
||||
addr = ("127.0.0.1", 0)
|
||||
assert not thisproc.connections(kind='tcp4')
|
||||
server, client = tcp_socketpair(AF_INET, addr=addr)
|
||||
try:
|
||||
cons = thisproc.connections(kind='tcp4')
|
||||
self.assertEqual(len(cons), 2)
|
||||
self.assertEqual(cons[0].status, psutil.CONN_ESTABLISHED)
|
||||
self.assertEqual(cons[1].status, psutil.CONN_ESTABLISHED)
|
||||
# May not be fast enough to change state so it stays
|
||||
# commenteed.
|
||||
# client.close()
|
||||
# cons = thisproc.connections(kind='all')
|
||||
# self.assertEqual(len(cons), 1)
|
||||
# self.assertEqual(cons[0].status, psutil.CONN_CLOSE_WAIT)
|
||||
finally:
|
||||
server.close()
|
||||
client.close()
|
||||
|
||||
@unittest.skipIf(not POSIX, 'POSIX only')
|
||||
def test_unix(self):
|
||||
testfn = self.get_testfn()
|
||||
server, client = unix_socketpair(testfn)
|
||||
try:
|
||||
cons = thisproc.connections(kind='unix')
|
||||
assert not (cons[0].laddr and cons[0].raddr)
|
||||
assert not (cons[1].laddr and cons[1].raddr)
|
||||
if NETBSD or FREEBSD:
|
||||
# On NetBSD creating a UNIX socket will cause
|
||||
# a UNIX connection to /var/run/log.
|
||||
cons = [c for c in cons if c.raddr != '/var/run/log']
|
||||
self.assertEqual(len(cons), 2, msg=cons)
|
||||
if LINUX or FREEBSD or SUNOS or OPENBSD:
|
||||
# remote path is never set
|
||||
self.assertEqual(cons[0].raddr, "")
|
||||
self.assertEqual(cons[1].raddr, "")
|
||||
# one local address should though
|
||||
self.assertEqual(testfn, cons[0].laddr or cons[1].laddr)
|
||||
else:
|
||||
# On other systems either the laddr or raddr
|
||||
# of both peers are set.
|
||||
self.assertEqual(cons[0].laddr or cons[1].laddr, testfn)
|
||||
finally:
|
||||
server.close()
|
||||
client.close()
|
||||
|
||||
|
||||
class TestFilters(ConnectionTestCase):
|
||||
|
||||
def test_filters(self):
|
||||
def check(kind, families, types):
|
||||
for conn in thisproc.connections(kind=kind):
|
||||
self.assertIn(conn.family, families)
|
||||
self.assertIn(conn.type, types)
|
||||
if not SKIP_SYSCONS:
|
||||
for conn in psutil.net_connections(kind=kind):
|
||||
self.assertIn(conn.family, families)
|
||||
self.assertIn(conn.type, types)
|
||||
|
||||
with create_sockets():
|
||||
check('all',
|
||||
[AF_INET, AF_INET6, AF_UNIX],
|
||||
[SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET])
|
||||
check('inet',
|
||||
[AF_INET, AF_INET6],
|
||||
[SOCK_STREAM, SOCK_DGRAM])
|
||||
check('inet4',
|
||||
[AF_INET],
|
||||
[SOCK_STREAM, SOCK_DGRAM])
|
||||
check('tcp',
|
||||
[AF_INET, AF_INET6],
|
||||
[SOCK_STREAM])
|
||||
check('tcp4',
|
||||
[AF_INET],
|
||||
[SOCK_STREAM])
|
||||
check('tcp6',
|
||||
[AF_INET6],
|
||||
[SOCK_STREAM])
|
||||
check('udp',
|
||||
[AF_INET, AF_INET6],
|
||||
[SOCK_DGRAM])
|
||||
check('udp4',
|
||||
[AF_INET],
|
||||
[SOCK_DGRAM])
|
||||
check('udp6',
|
||||
[AF_INET6],
|
||||
[SOCK_DGRAM])
|
||||
if HAS_CONNECTIONS_UNIX:
|
||||
check('unix',
|
||||
[AF_UNIX],
|
||||
[SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET])
|
||||
|
||||
@skip_on_access_denied(only_if=MACOS)
|
||||
def test_combos(self):
|
||||
reap_children()
|
||||
|
||||
def check_conn(proc, conn, family, type, laddr, raddr, status, kinds):
|
||||
all_kinds = ("all", "inet", "inet4", "inet6", "tcp", "tcp4",
|
||||
"tcp6", "udp", "udp4", "udp6")
|
||||
check_connection_ntuple(conn)
|
||||
self.assertEqual(conn.family, family)
|
||||
self.assertEqual(conn.type, type)
|
||||
self.assertEqual(conn.laddr, laddr)
|
||||
self.assertEqual(conn.raddr, raddr)
|
||||
self.assertEqual(conn.status, status)
|
||||
for kind in all_kinds:
|
||||
cons = proc.connections(kind=kind)
|
||||
if kind in kinds:
|
||||
assert cons
|
||||
else:
|
||||
assert not cons, cons
|
||||
# compare against system-wide connections
|
||||
# XXX Solaris can't retrieve system-wide UNIX
|
||||
# sockets.
|
||||
if HAS_CONNECTIONS_UNIX:
|
||||
self.compare_procsys_connections(proc.pid, [conn])
|
||||
|
||||
tcp_template = textwrap.dedent("""
|
||||
import socket, time
|
||||
s = socket.socket({family}, socket.SOCK_STREAM)
|
||||
s.bind(('{addr}', 0))
|
||||
s.listen(5)
|
||||
with open('{testfn}', 'w') as f:
|
||||
f.write(str(s.getsockname()[:2]))
|
||||
time.sleep(60)
|
||||
""")
|
||||
|
||||
udp_template = textwrap.dedent("""
|
||||
import socket, time
|
||||
s = socket.socket({family}, socket.SOCK_DGRAM)
|
||||
s.bind(('{addr}', 0))
|
||||
with open('{testfn}', 'w') as f:
|
||||
f.write(str(s.getsockname()[:2]))
|
||||
time.sleep(60)
|
||||
""")
|
||||
|
||||
# must be relative on Windows
|
||||
testfile = os.path.basename(self.get_testfn(dir=os.getcwd()))
|
||||
tcp4_template = tcp_template.format(
|
||||
family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
|
||||
udp4_template = udp_template.format(
|
||||
family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
|
||||
tcp6_template = tcp_template.format(
|
||||
family=int(AF_INET6), addr="::1", testfn=testfile)
|
||||
udp6_template = udp_template.format(
|
||||
family=int(AF_INET6), addr="::1", testfn=testfile)
|
||||
|
||||
# launch various subprocess instantiating a socket of various
|
||||
# families and types to enrich psutil results
|
||||
tcp4_proc = self.pyrun(tcp4_template)
|
||||
tcp4_addr = eval(wait_for_file(testfile, delete=True))
|
||||
udp4_proc = self.pyrun(udp4_template)
|
||||
udp4_addr = eval(wait_for_file(testfile, delete=True))
|
||||
if supports_ipv6():
|
||||
tcp6_proc = self.pyrun(tcp6_template)
|
||||
tcp6_addr = eval(wait_for_file(testfile, delete=True))
|
||||
udp6_proc = self.pyrun(udp6_template)
|
||||
udp6_addr = eval(wait_for_file(testfile, delete=True))
|
||||
else:
|
||||
tcp6_proc = None
|
||||
udp6_proc = None
|
||||
tcp6_addr = None
|
||||
udp6_addr = None
|
||||
|
||||
for p in thisproc.children():
|
||||
cons = p.connections()
|
||||
self.assertEqual(len(cons), 1)
|
||||
for conn in cons:
|
||||
# TCP v4
|
||||
if p.pid == tcp4_proc.pid:
|
||||
check_conn(p, conn, AF_INET, SOCK_STREAM, tcp4_addr, (),
|
||||
psutil.CONN_LISTEN,
|
||||
("all", "inet", "inet4", "tcp", "tcp4"))
|
||||
# UDP v4
|
||||
elif p.pid == udp4_proc.pid:
|
||||
check_conn(p, conn, AF_INET, SOCK_DGRAM, udp4_addr, (),
|
||||
psutil.CONN_NONE,
|
||||
("all", "inet", "inet4", "udp", "udp4"))
|
||||
# TCP v6
|
||||
elif p.pid == getattr(tcp6_proc, "pid", None):
|
||||
check_conn(p, conn, AF_INET6, SOCK_STREAM, tcp6_addr, (),
|
||||
psutil.CONN_LISTEN,
|
||||
("all", "inet", "inet6", "tcp", "tcp6"))
|
||||
# UDP v6
|
||||
elif p.pid == getattr(udp6_proc, "pid", None):
|
||||
check_conn(p, conn, AF_INET6, SOCK_DGRAM, udp6_addr, (),
|
||||
psutil.CONN_NONE,
|
||||
("all", "inet", "inet6", "udp", "udp6"))
|
||||
|
||||
def test_count(self):
|
||||
with create_sockets():
|
||||
# tcp
|
||||
cons = thisproc.connections(kind='tcp')
|
||||
self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
|
||||
for conn in cons:
|
||||
self.assertIn(conn.family, (AF_INET, AF_INET6))
|
||||
self.assertEqual(conn.type, SOCK_STREAM)
|
||||
# tcp4
|
||||
cons = thisproc.connections(kind='tcp4')
|
||||
self.assertEqual(len(cons), 1)
|
||||
self.assertEqual(cons[0].family, AF_INET)
|
||||
self.assertEqual(cons[0].type, SOCK_STREAM)
|
||||
# tcp6
|
||||
if supports_ipv6():
|
||||
cons = thisproc.connections(kind='tcp6')
|
||||
self.assertEqual(len(cons), 1)
|
||||
self.assertEqual(cons[0].family, AF_INET6)
|
||||
self.assertEqual(cons[0].type, SOCK_STREAM)
|
||||
# udp
|
||||
cons = thisproc.connections(kind='udp')
|
||||
self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
|
||||
for conn in cons:
|
||||
self.assertIn(conn.family, (AF_INET, AF_INET6))
|
||||
self.assertEqual(conn.type, SOCK_DGRAM)
|
||||
# udp4
|
||||
cons = thisproc.connections(kind='udp4')
|
||||
self.assertEqual(len(cons), 1)
|
||||
self.assertEqual(cons[0].family, AF_INET)
|
||||
self.assertEqual(cons[0].type, SOCK_DGRAM)
|
||||
# udp6
|
||||
if supports_ipv6():
|
||||
cons = thisproc.connections(kind='udp6')
|
||||
self.assertEqual(len(cons), 1)
|
||||
self.assertEqual(cons[0].family, AF_INET6)
|
||||
self.assertEqual(cons[0].type, SOCK_DGRAM)
|
||||
# inet
|
||||
cons = thisproc.connections(kind='inet')
|
||||
self.assertEqual(len(cons), 4 if supports_ipv6() else 2)
|
||||
for conn in cons:
|
||||
self.assertIn(conn.family, (AF_INET, AF_INET6))
|
||||
self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
|
||||
# inet6
|
||||
if supports_ipv6():
|
||||
cons = thisproc.connections(kind='inet6')
|
||||
self.assertEqual(len(cons), 2)
|
||||
for conn in cons:
|
||||
self.assertEqual(conn.family, AF_INET6)
|
||||
self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
|
||||
# Skipped on BSD becayse by default the Python process
|
||||
# creates a UNIX socket to '/var/run/log'.
|
||||
if HAS_CONNECTIONS_UNIX and not (FREEBSD or NETBSD):
|
||||
cons = thisproc.connections(kind='unix')
|
||||
self.assertEqual(len(cons), 3)
|
||||
for conn in cons:
|
||||
self.assertEqual(conn.family, AF_UNIX)
|
||||
self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
|
||||
|
||||
|
||||
@unittest.skipIf(SKIP_SYSCONS, "requires root")
|
||||
class TestSystemWideConnections(ConnectionTestCase):
|
||||
"""Tests for net_connections()."""
|
||||
|
||||
def test_it(self):
|
||||
def check(cons, families, types_):
|
||||
for conn in cons:
|
||||
self.assertIn(conn.family, families, msg=conn)
|
||||
if conn.family != AF_UNIX:
|
||||
self.assertIn(conn.type, types_, msg=conn)
|
||||
check_connection_ntuple(conn)
|
||||
|
||||
with create_sockets():
|
||||
from psutil._common import conn_tmap
|
||||
for kind, groups in conn_tmap.items():
|
||||
# XXX: SunOS does not retrieve UNIX sockets.
|
||||
if kind == 'unix' and not HAS_CONNECTIONS_UNIX:
|
||||
continue
|
||||
families, types_ = groups
|
||||
cons = psutil.net_connections(kind)
|
||||
self.assertEqual(len(cons), len(set(cons)))
|
||||
check(cons, families, types_)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_multi_sockets_procs(self):
|
||||
# Creates multiple sub processes, each creating different
|
||||
# sockets. For each process check that proc.connections()
|
||||
# and net_connections() return the same results.
|
||||
# This is done mainly to check whether net_connections()'s
|
||||
# pid is properly set, see:
|
||||
# https://github.com/giampaolo/psutil/issues/1013
|
||||
with create_sockets() as socks:
|
||||
expected = len(socks)
|
||||
pids = []
|
||||
times = 10
|
||||
fnames = []
|
||||
for _ in range(times):
|
||||
fname = self.get_testfn()
|
||||
fnames.append(fname)
|
||||
src = textwrap.dedent("""\
|
||||
import time, os
|
||||
from psutil.tests import create_sockets
|
||||
with create_sockets():
|
||||
with open(r'%s', 'w') as f:
|
||||
f.write("hello")
|
||||
time.sleep(60)
|
||||
""" % fname)
|
||||
sproc = self.pyrun(src)
|
||||
pids.append(sproc.pid)
|
||||
|
||||
# sync
|
||||
for fname in fnames:
|
||||
wait_for_file(fname)
|
||||
|
||||
syscons = [x for x in psutil.net_connections(kind='all') if x.pid
|
||||
in pids]
|
||||
for pid in pids:
|
||||
self.assertEqual(len([x for x in syscons if x.pid == pid]),
|
||||
expected)
|
||||
p = psutil.Process(pid)
|
||||
self.assertEqual(len(p.connections('all')), expected)
|
||||
|
||||
|
||||
class TestMisc(PsutilTestCase):
|
||||
|
||||
def test_connection_constants(self):
|
||||
ints = []
|
||||
strs = []
|
||||
for name in dir(psutil):
|
||||
if name.startswith('CONN_'):
|
||||
num = getattr(psutil, name)
|
||||
str_ = str(num)
|
||||
assert str_.isupper(), str_
|
||||
self.assertNotIn(str, strs)
|
||||
self.assertNotIn(num, ints)
|
||||
ints.append(num)
|
||||
strs.append(str_)
|
||||
if SUNOS:
|
||||
psutil.CONN_IDLE
|
||||
psutil.CONN_BOUND
|
||||
if WINDOWS:
|
||||
psutil.CONN_DELETE_TCB
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,752 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""Contracts tests. These tests mainly check API sanity in terms of
|
||||
returned types and APIs availability.
|
||||
Some of these are duplicates of tests test_system.py and test_process.py
|
||||
"""
|
||||
|
||||
import errno
|
||||
import multiprocessing
|
||||
import os
|
||||
import platform
|
||||
import signal
|
||||
import stat
|
||||
import sys
|
||||
import time
|
||||
import traceback
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
from psutil import AIX
|
||||
from psutil import BSD
|
||||
from psutil import FREEBSD
|
||||
from psutil import LINUX
|
||||
from psutil import MACOS
|
||||
from psutil import NETBSD
|
||||
from psutil import OPENBSD
|
||||
from psutil import OSX
|
||||
from psutil import POSIX
|
||||
from psutil import SUNOS
|
||||
from psutil import WINDOWS
|
||||
from psutil._compat import FileNotFoundError
|
||||
from psutil._compat import long
|
||||
from psutil._compat import range
|
||||
from psutil._compat import unicode
|
||||
from psutil.tests import APPVEYOR
|
||||
from psutil.tests import CI_TESTING
|
||||
from psutil.tests import GITHUB_ACTIONS
|
||||
from psutil.tests import HAS_CPU_FREQ
|
||||
from psutil.tests import HAS_NET_IO_COUNTERS
|
||||
from psutil.tests import HAS_SENSORS_FANS
|
||||
from psutil.tests import HAS_SENSORS_TEMPERATURES
|
||||
from psutil.tests import PYPY
|
||||
from psutil.tests import SKIP_SYSCONS
|
||||
from psutil.tests import VALID_PROC_STATUSES
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import check_connection_ntuple
|
||||
from psutil.tests import create_sockets
|
||||
from psutil.tests import enum
|
||||
from psutil.tests import is_namedtuple
|
||||
from psutil.tests import kernel_version
|
||||
from psutil.tests import process_namespace
|
||||
from psutil.tests import serialrun
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- APIs availability
|
||||
# ===================================================================
|
||||
|
||||
# Make sure code reflects what doc promises in terms of APIs
|
||||
# availability.
|
||||
|
||||
class TestAvailConstantsAPIs(PsutilTestCase):
|
||||
|
||||
def test_PROCFS_PATH(self):
|
||||
self.assertEqual(hasattr(psutil, "PROCFS_PATH"),
|
||||
LINUX or SUNOS or AIX)
|
||||
|
||||
def test_win_priority(self):
|
||||
ae = self.assertEqual
|
||||
ae(hasattr(psutil, "ABOVE_NORMAL_PRIORITY_CLASS"), WINDOWS)
|
||||
ae(hasattr(psutil, "BELOW_NORMAL_PRIORITY_CLASS"), WINDOWS)
|
||||
ae(hasattr(psutil, "HIGH_PRIORITY_CLASS"), WINDOWS)
|
||||
ae(hasattr(psutil, "IDLE_PRIORITY_CLASS"), WINDOWS)
|
||||
ae(hasattr(psutil, "NORMAL_PRIORITY_CLASS"), WINDOWS)
|
||||
ae(hasattr(psutil, "REALTIME_PRIORITY_CLASS"), WINDOWS)
|
||||
|
||||
def test_linux_ioprio_linux(self):
|
||||
ae = self.assertEqual
|
||||
ae(hasattr(psutil, "IOPRIO_CLASS_NONE"), LINUX)
|
||||
ae(hasattr(psutil, "IOPRIO_CLASS_RT"), LINUX)
|
||||
ae(hasattr(psutil, "IOPRIO_CLASS_BE"), LINUX)
|
||||
ae(hasattr(psutil, "IOPRIO_CLASS_IDLE"), LINUX)
|
||||
|
||||
def test_linux_ioprio_windows(self):
|
||||
ae = self.assertEqual
|
||||
ae(hasattr(psutil, "IOPRIO_HIGH"), WINDOWS)
|
||||
ae(hasattr(psutil, "IOPRIO_NORMAL"), WINDOWS)
|
||||
ae(hasattr(psutil, "IOPRIO_LOW"), WINDOWS)
|
||||
ae(hasattr(psutil, "IOPRIO_VERYLOW"), WINDOWS)
|
||||
|
||||
@unittest.skipIf(GITHUB_ACTIONS and LINUX,
|
||||
"unsupported on GITHUB_ACTIONS + LINUX")
|
||||
def test_rlimit(self):
|
||||
ae = self.assertEqual
|
||||
ae(hasattr(psutil, "RLIM_INFINITY"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_AS"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_CORE"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_CPU"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_DATA"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_FSIZE"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_MEMLOCK"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_NOFILE"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_NPROC"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_RSS"), LINUX or FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_STACK"), LINUX or FREEBSD)
|
||||
|
||||
ae(hasattr(psutil, "RLIMIT_LOCKS"), LINUX)
|
||||
if POSIX:
|
||||
if kernel_version() >= (2, 6, 8):
|
||||
ae(hasattr(psutil, "RLIMIT_MSGQUEUE"), LINUX)
|
||||
if kernel_version() >= (2, 6, 12):
|
||||
ae(hasattr(psutil, "RLIMIT_NICE"), LINUX)
|
||||
if kernel_version() >= (2, 6, 12):
|
||||
ae(hasattr(psutil, "RLIMIT_RTPRIO"), LINUX)
|
||||
if kernel_version() >= (2, 6, 25):
|
||||
ae(hasattr(psutil, "RLIMIT_RTTIME"), LINUX)
|
||||
if kernel_version() >= (2, 6, 8):
|
||||
ae(hasattr(psutil, "RLIMIT_SIGPENDING"), LINUX)
|
||||
|
||||
ae(hasattr(psutil, "RLIMIT_SWAP"), FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_SBSIZE"), FREEBSD)
|
||||
ae(hasattr(psutil, "RLIMIT_NPTS"), FREEBSD)
|
||||
|
||||
|
||||
class TestAvailSystemAPIs(PsutilTestCase):
|
||||
|
||||
def test_win_service_iter(self):
|
||||
self.assertEqual(hasattr(psutil, "win_service_iter"), WINDOWS)
|
||||
|
||||
def test_win_service_get(self):
|
||||
self.assertEqual(hasattr(psutil, "win_service_get"), WINDOWS)
|
||||
|
||||
def test_cpu_freq(self):
|
||||
self.assertEqual(hasattr(psutil, "cpu_freq"),
|
||||
LINUX or MACOS or WINDOWS or FREEBSD or OPENBSD)
|
||||
|
||||
def test_sensors_temperatures(self):
|
||||
self.assertEqual(
|
||||
hasattr(psutil, "sensors_temperatures"), LINUX or FREEBSD)
|
||||
|
||||
def test_sensors_fans(self):
|
||||
self.assertEqual(hasattr(psutil, "sensors_fans"), LINUX)
|
||||
|
||||
def test_battery(self):
|
||||
self.assertEqual(hasattr(psutil, "sensors_battery"),
|
||||
LINUX or WINDOWS or FREEBSD or MACOS)
|
||||
|
||||
|
||||
class TestAvailProcessAPIs(PsutilTestCase):
|
||||
|
||||
def test_environ(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "environ"),
|
||||
LINUX or MACOS or WINDOWS or AIX or SUNOS or
|
||||
FREEBSD or OPENBSD or NETBSD)
|
||||
|
||||
def test_uids(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "uids"), POSIX)
|
||||
|
||||
def test_gids(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "uids"), POSIX)
|
||||
|
||||
def test_terminal(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "terminal"), POSIX)
|
||||
|
||||
def test_ionice(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "ionice"), LINUX or WINDOWS)
|
||||
|
||||
@unittest.skipIf(GITHUB_ACTIONS and LINUX,
|
||||
"unsupported on GITHUB_ACTIONS + LINUX")
|
||||
def test_rlimit(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "rlimit"), LINUX or FREEBSD)
|
||||
|
||||
def test_io_counters(self):
|
||||
hasit = hasattr(psutil.Process, "io_counters")
|
||||
self.assertEqual(hasit, not (MACOS or SUNOS))
|
||||
|
||||
def test_num_fds(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "num_fds"), POSIX)
|
||||
|
||||
def test_num_handles(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "num_handles"), WINDOWS)
|
||||
|
||||
def test_cpu_affinity(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "cpu_affinity"),
|
||||
LINUX or WINDOWS or FREEBSD)
|
||||
|
||||
def test_cpu_num(self):
|
||||
self.assertEqual(hasattr(psutil.Process, "cpu_num"),
|
||||
LINUX or FREEBSD or SUNOS)
|
||||
|
||||
def test_memory_maps(self):
|
||||
hasit = hasattr(psutil.Process, "memory_maps")
|
||||
self.assertEqual(
|
||||
hasit, False if OPENBSD or NETBSD or AIX or MACOS else True)
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- API types
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestSystemAPITypes(PsutilTestCase):
|
||||
"""Check the return types of system related APIs.
|
||||
Mainly we want to test we never return unicode on Python 2, see:
|
||||
https://github.com/giampaolo/psutil/issues/1039
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.proc = psutil.Process()
|
||||
|
||||
def assert_ntuple_of_nums(self, nt, type_=float, gezero=True):
|
||||
assert is_namedtuple(nt)
|
||||
for n in nt:
|
||||
self.assertIsInstance(n, type_)
|
||||
if gezero:
|
||||
self.assertGreaterEqual(n, 0)
|
||||
|
||||
def test_cpu_times(self):
|
||||
self.assert_ntuple_of_nums(psutil.cpu_times())
|
||||
for nt in psutil.cpu_times(percpu=True):
|
||||
self.assert_ntuple_of_nums(nt)
|
||||
|
||||
def test_cpu_percent(self):
|
||||
self.assertIsInstance(psutil.cpu_percent(interval=None), float)
|
||||
self.assertIsInstance(psutil.cpu_percent(interval=0.00001), float)
|
||||
|
||||
def test_cpu_times_percent(self):
|
||||
self.assert_ntuple_of_nums(psutil.cpu_times_percent(interval=None))
|
||||
self.assert_ntuple_of_nums(psutil.cpu_times_percent(interval=0.0001))
|
||||
|
||||
def test_cpu_count(self):
|
||||
self.assertIsInstance(psutil.cpu_count(), int)
|
||||
|
||||
# TODO: remove this once 1892 is fixed
|
||||
@unittest.skipIf(MACOS and platform.machine() == 'arm64',
|
||||
"skipped due to #1892")
|
||||
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
|
||||
def test_cpu_freq(self):
|
||||
if psutil.cpu_freq() is None:
|
||||
raise self.skipTest("cpu_freq() returns None")
|
||||
self.assert_ntuple_of_nums(psutil.cpu_freq(), type_=(float, int, long))
|
||||
|
||||
def test_disk_io_counters(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for k, v in psutil.disk_io_counters(perdisk=True).items():
|
||||
self.assertIsInstance(k, str)
|
||||
self.assert_ntuple_of_nums(v, type_=(int, long))
|
||||
|
||||
def test_disk_partitions(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for disk in psutil.disk_partitions():
|
||||
self.assertIsInstance(disk.device, str)
|
||||
self.assertIsInstance(disk.mountpoint, str)
|
||||
self.assertIsInstance(disk.fstype, str)
|
||||
self.assertIsInstance(disk.opts, str)
|
||||
self.assertIsInstance(disk.maxfile, (int, type(None)))
|
||||
self.assertIsInstance(disk.maxpath, (int, type(None)))
|
||||
|
||||
@unittest.skipIf(SKIP_SYSCONS, "requires root")
|
||||
def test_net_connections(self):
|
||||
with create_sockets():
|
||||
ret = psutil.net_connections('all')
|
||||
self.assertEqual(len(ret), len(set(ret)))
|
||||
for conn in ret:
|
||||
assert is_namedtuple(conn)
|
||||
|
||||
def test_net_if_addrs(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for ifname, addrs in psutil.net_if_addrs().items():
|
||||
self.assertIsInstance(ifname, str)
|
||||
for addr in addrs:
|
||||
if enum is not None and not PYPY:
|
||||
self.assertIsInstance(addr.family, enum.IntEnum)
|
||||
else:
|
||||
self.assertIsInstance(addr.family, int)
|
||||
self.assertIsInstance(addr.address, str)
|
||||
self.assertIsInstance(addr.netmask, (str, type(None)))
|
||||
self.assertIsInstance(addr.broadcast, (str, type(None)))
|
||||
|
||||
def test_net_if_stats(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for ifname, info in psutil.net_if_stats().items():
|
||||
self.assertIsInstance(ifname, str)
|
||||
self.assertIsInstance(info.isup, bool)
|
||||
if enum is not None:
|
||||
self.assertIsInstance(info.duplex, enum.IntEnum)
|
||||
else:
|
||||
self.assertIsInstance(info.duplex, int)
|
||||
self.assertIsInstance(info.speed, int)
|
||||
self.assertIsInstance(info.mtu, int)
|
||||
|
||||
@unittest.skipIf(not HAS_NET_IO_COUNTERS, 'not supported')
|
||||
def test_net_io_counters(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for ifname, _ in psutil.net_io_counters(pernic=True).items():
|
||||
self.assertIsInstance(ifname, str)
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_FANS, "not supported")
|
||||
def test_sensors_fans(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for name, units in psutil.sensors_fans().items():
|
||||
self.assertIsInstance(name, str)
|
||||
for unit in units:
|
||||
self.assertIsInstance(unit.label, str)
|
||||
self.assertIsInstance(unit.current, (float, int, type(None)))
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_TEMPERATURES, "not supported")
|
||||
def test_sensors_temperatures(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for name, units in psutil.sensors_temperatures().items():
|
||||
self.assertIsInstance(name, str)
|
||||
for unit in units:
|
||||
self.assertIsInstance(unit.label, str)
|
||||
self.assertIsInstance(unit.current, (float, int, type(None)))
|
||||
self.assertIsInstance(unit.high, (float, int, type(None)))
|
||||
self.assertIsInstance(unit.critical, (float, int, type(None)))
|
||||
|
||||
def test_boot_time(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
self.assertIsInstance(psutil.boot_time(), float)
|
||||
|
||||
def test_users(self):
|
||||
# Duplicate of test_system.py. Keep it anyway.
|
||||
for user in psutil.users():
|
||||
self.assertIsInstance(user.name, str)
|
||||
self.assertIsInstance(user.terminal, (str, type(None)))
|
||||
self.assertIsInstance(user.host, (str, type(None)))
|
||||
self.assertIsInstance(user.pid, (int, type(None)))
|
||||
|
||||
|
||||
class TestProcessWaitType(PsutilTestCase):
|
||||
|
||||
@unittest.skipIf(not POSIX, "not POSIX")
|
||||
def test_negative_signal(self):
|
||||
p = psutil.Process(self.spawn_testproc().pid)
|
||||
p.terminate()
|
||||
code = p.wait()
|
||||
self.assertEqual(code, -signal.SIGTERM)
|
||||
if enum is not None:
|
||||
self.assertIsInstance(code, enum.IntEnum)
|
||||
else:
|
||||
self.assertIsInstance(code, int)
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- Featch all processes test
|
||||
# ===================================================================
|
||||
|
||||
|
||||
def proc_info(pid):
|
||||
tcase = PsutilTestCase()
|
||||
|
||||
def check_exception(exc, proc, name, ppid):
|
||||
tcase.assertEqual(exc.pid, pid)
|
||||
tcase.assertEqual(exc.name, name)
|
||||
if isinstance(exc, psutil.ZombieProcess):
|
||||
if exc.ppid is not None:
|
||||
tcase.assertGreaterEqual(exc.ppid, 0)
|
||||
tcase.assertEqual(exc.ppid, ppid)
|
||||
elif isinstance(exc, psutil.NoSuchProcess):
|
||||
tcase.assertProcessGone(proc)
|
||||
str(exc)
|
||||
|
||||
def do_wait():
|
||||
if pid != 0:
|
||||
try:
|
||||
proc.wait(0)
|
||||
except psutil.Error as exc:
|
||||
check_exception(exc, proc, name, ppid)
|
||||
|
||||
try:
|
||||
proc = psutil.Process(pid)
|
||||
d = proc.as_dict(['ppid', 'name'])
|
||||
except psutil.NoSuchProcess:
|
||||
return {}
|
||||
|
||||
name, ppid = d['name'], d['ppid']
|
||||
info = {'pid': proc.pid}
|
||||
ns = process_namespace(proc)
|
||||
# We don't use oneshot() because in order not to fool
|
||||
# check_exception() in case of NSP.
|
||||
for fun, fun_name in ns.iter(ns.getters, clear_cache=False):
|
||||
try:
|
||||
info[fun_name] = fun()
|
||||
except psutil.Error as exc:
|
||||
check_exception(exc, proc, name, ppid)
|
||||
continue
|
||||
do_wait()
|
||||
return info
|
||||
|
||||
|
||||
@serialrun
|
||||
class TestFetchAllProcesses(PsutilTestCase):
|
||||
"""Test which iterates over all running processes and performs
|
||||
some sanity checks against Process API's returned values.
|
||||
Uses a process pool to get info about all processes.
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
# Using a pool in a CI env may result in deadlock, see:
|
||||
# https://github.com/giampaolo/psutil/issues/2104
|
||||
if not CI_TESTING:
|
||||
self.pool = multiprocessing.Pool()
|
||||
|
||||
def tearDown(self):
|
||||
if not CI_TESTING:
|
||||
self.pool.terminate()
|
||||
self.pool.join()
|
||||
|
||||
def iter_proc_info(self):
|
||||
# Fixes "can't pickle <function proc_info>: it's not the
|
||||
# same object as test_contracts.proc_info".
|
||||
from psutil.tests.test_contracts import proc_info
|
||||
|
||||
if not CI_TESTING:
|
||||
return self.pool.imap_unordered(proc_info, psutil.pids())
|
||||
else:
|
||||
ls = []
|
||||
for pid in psutil.pids():
|
||||
ls.append(proc_info(pid))
|
||||
return ls
|
||||
|
||||
def test_all(self):
|
||||
failures = []
|
||||
for info in self.iter_proc_info():
|
||||
for name, value in info.items():
|
||||
meth = getattr(self, name)
|
||||
try:
|
||||
meth(value, info)
|
||||
except AssertionError:
|
||||
s = '\n' + '=' * 70 + '\n'
|
||||
s += "FAIL: test_%s pid=%s, ret=%s\n" % (
|
||||
name, info['pid'], repr(value))
|
||||
s += '-' * 70
|
||||
s += "\n%s" % traceback.format_exc()
|
||||
s = "\n".join((" " * 4) + i for i in s.splitlines()) + "\n"
|
||||
failures.append(s)
|
||||
else:
|
||||
if value not in (0, 0.0, [], None, '', {}):
|
||||
assert value, value
|
||||
if failures:
|
||||
raise self.fail(''.join(failures))
|
||||
|
||||
def cmdline(self, ret, info):
|
||||
self.assertIsInstance(ret, list)
|
||||
for part in ret:
|
||||
self.assertIsInstance(part, str)
|
||||
|
||||
def exe(self, ret, info):
|
||||
self.assertIsInstance(ret, (str, unicode))
|
||||
self.assertEqual(ret.strip(), ret)
|
||||
if ret:
|
||||
if WINDOWS and not ret.endswith('.exe'):
|
||||
return # May be "Registry", "MemCompression", ...
|
||||
assert os.path.isabs(ret), ret
|
||||
# Note: os.stat() may return False even if the file is there
|
||||
# hence we skip the test, see:
|
||||
# http://stackoverflow.com/questions/3112546/os-path-exists-lies
|
||||
if POSIX and os.path.isfile(ret):
|
||||
if hasattr(os, 'access') and hasattr(os, "X_OK"):
|
||||
# XXX: may fail on MACOS
|
||||
try:
|
||||
assert os.access(ret, os.X_OK)
|
||||
except AssertionError:
|
||||
if os.path.exists(ret) and not CI_TESTING:
|
||||
raise
|
||||
|
||||
def pid(self, ret, info):
|
||||
self.assertIsInstance(ret, int)
|
||||
self.assertGreaterEqual(ret, 0)
|
||||
|
||||
def ppid(self, ret, info):
|
||||
self.assertIsInstance(ret, (int, long))
|
||||
self.assertGreaterEqual(ret, 0)
|
||||
|
||||
def name(self, ret, info):
|
||||
self.assertIsInstance(ret, (str, unicode))
|
||||
if APPVEYOR and not ret and info['status'] == 'stopped':
|
||||
return
|
||||
# on AIX, "<exiting>" processes don't have names
|
||||
if not AIX:
|
||||
assert ret
|
||||
|
||||
def create_time(self, ret, info):
|
||||
self.assertIsInstance(ret, float)
|
||||
try:
|
||||
self.assertGreaterEqual(ret, 0)
|
||||
except AssertionError:
|
||||
# XXX
|
||||
if OPENBSD and info['status'] == psutil.STATUS_ZOMBIE:
|
||||
pass
|
||||
else:
|
||||
raise
|
||||
# this can't be taken for granted on all platforms
|
||||
# self.assertGreaterEqual(ret, psutil.boot_time())
|
||||
# make sure returned value can be pretty printed
|
||||
# with strftime
|
||||
time.strftime("%Y %m %d %H:%M:%S", time.localtime(ret))
|
||||
|
||||
def uids(self, ret, info):
|
||||
assert is_namedtuple(ret)
|
||||
for uid in ret:
|
||||
self.assertIsInstance(uid, int)
|
||||
self.assertGreaterEqual(uid, 0)
|
||||
|
||||
def gids(self, ret, info):
|
||||
assert is_namedtuple(ret)
|
||||
# note: testing all gids as above seems not to be reliable for
|
||||
# gid == 30 (nodoby); not sure why.
|
||||
for gid in ret:
|
||||
self.assertIsInstance(gid, int)
|
||||
if not MACOS and not NETBSD:
|
||||
self.assertGreaterEqual(gid, 0)
|
||||
|
||||
def username(self, ret, info):
|
||||
self.assertIsInstance(ret, str)
|
||||
self.assertEqual(ret.strip(), ret)
|
||||
assert ret.strip()
|
||||
|
||||
def status(self, ret, info):
|
||||
self.assertIsInstance(ret, str)
|
||||
assert ret
|
||||
self.assertNotEqual(ret, '?') # XXX
|
||||
self.assertIn(ret, VALID_PROC_STATUSES)
|
||||
|
||||
def io_counters(self, ret, info):
|
||||
assert is_namedtuple(ret)
|
||||
for field in ret:
|
||||
self.assertIsInstance(field, (int, long))
|
||||
if field != -1:
|
||||
self.assertGreaterEqual(field, 0)
|
||||
|
||||
def ionice(self, ret, info):
|
||||
if LINUX:
|
||||
self.assertIsInstance(ret.ioclass, int)
|
||||
self.assertIsInstance(ret.value, int)
|
||||
self.assertGreaterEqual(ret.ioclass, 0)
|
||||
self.assertGreaterEqual(ret.value, 0)
|
||||
else: # Windows, Cygwin
|
||||
choices = [
|
||||
psutil.IOPRIO_VERYLOW,
|
||||
psutil.IOPRIO_LOW,
|
||||
psutil.IOPRIO_NORMAL,
|
||||
psutil.IOPRIO_HIGH]
|
||||
self.assertIsInstance(ret, int)
|
||||
self.assertGreaterEqual(ret, 0)
|
||||
self.assertIn(ret, choices)
|
||||
|
||||
def num_threads(self, ret, info):
|
||||
self.assertIsInstance(ret, int)
|
||||
if APPVEYOR and not ret and info['status'] == 'stopped':
|
||||
return
|
||||
self.assertGreaterEqual(ret, 1)
|
||||
|
||||
def threads(self, ret, info):
|
||||
self.assertIsInstance(ret, list)
|
||||
for t in ret:
|
||||
assert is_namedtuple(t)
|
||||
self.assertGreaterEqual(t.id, 0)
|
||||
self.assertGreaterEqual(t.user_time, 0)
|
||||
self.assertGreaterEqual(t.system_time, 0)
|
||||
for field in t:
|
||||
self.assertIsInstance(field, (int, float))
|
||||
|
||||
def cpu_times(self, ret, info):
|
||||
assert is_namedtuple(ret)
|
||||
for n in ret:
|
||||
self.assertIsInstance(n, float)
|
||||
self.assertGreaterEqual(n, 0)
|
||||
# TODO: check ntuple fields
|
||||
|
||||
def cpu_percent(self, ret, info):
|
||||
self.assertIsInstance(ret, float)
|
||||
assert 0.0 <= ret <= 100.0, ret
|
||||
|
||||
def cpu_num(self, ret, info):
|
||||
self.assertIsInstance(ret, int)
|
||||
if FREEBSD and ret == -1:
|
||||
return
|
||||
self.assertGreaterEqual(ret, 0)
|
||||
if psutil.cpu_count() == 1:
|
||||
self.assertEqual(ret, 0)
|
||||
self.assertIn(ret, list(range(psutil.cpu_count())))
|
||||
|
||||
def memory_info(self, ret, info):
|
||||
assert is_namedtuple(ret)
|
||||
for value in ret:
|
||||
self.assertIsInstance(value, (int, long))
|
||||
self.assertGreaterEqual(value, 0)
|
||||
if WINDOWS:
|
||||
self.assertGreaterEqual(ret.peak_wset, ret.wset)
|
||||
self.assertGreaterEqual(ret.peak_paged_pool, ret.paged_pool)
|
||||
self.assertGreaterEqual(ret.peak_nonpaged_pool, ret.nonpaged_pool)
|
||||
self.assertGreaterEqual(ret.peak_pagefile, ret.pagefile)
|
||||
|
||||
def memory_full_info(self, ret, info):
|
||||
assert is_namedtuple(ret)
|
||||
total = psutil.virtual_memory().total
|
||||
for name in ret._fields:
|
||||
value = getattr(ret, name)
|
||||
self.assertIsInstance(value, (int, long))
|
||||
self.assertGreaterEqual(value, 0, msg=(name, value))
|
||||
if LINUX or OSX and name in ('vms', 'data'):
|
||||
# On Linux there are processes (e.g. 'goa-daemon') whose
|
||||
# VMS is incredibly high for some reason.
|
||||
continue
|
||||
self.assertLessEqual(value, total, msg=(name, value, total))
|
||||
|
||||
if LINUX:
|
||||
self.assertGreaterEqual(ret.pss, ret.uss)
|
||||
|
||||
def open_files(self, ret, info):
|
||||
self.assertIsInstance(ret, list)
|
||||
for f in ret:
|
||||
self.assertIsInstance(f.fd, int)
|
||||
self.assertIsInstance(f.path, str)
|
||||
self.assertEqual(f.path.strip(), f.path)
|
||||
if WINDOWS:
|
||||
self.assertEqual(f.fd, -1)
|
||||
elif LINUX:
|
||||
self.assertIsInstance(f.position, int)
|
||||
self.assertIsInstance(f.mode, str)
|
||||
self.assertIsInstance(f.flags, int)
|
||||
self.assertGreaterEqual(f.position, 0)
|
||||
self.assertIn(f.mode, ('r', 'w', 'a', 'r+', 'a+'))
|
||||
self.assertGreater(f.flags, 0)
|
||||
elif BSD and not f.path:
|
||||
# XXX see: https://github.com/giampaolo/psutil/issues/595
|
||||
continue
|
||||
assert os.path.isabs(f.path), f
|
||||
try:
|
||||
st = os.stat(f.path)
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
else:
|
||||
assert stat.S_ISREG(st.st_mode), f
|
||||
|
||||
def num_fds(self, ret, info):
|
||||
self.assertIsInstance(ret, int)
|
||||
self.assertGreaterEqual(ret, 0)
|
||||
|
||||
def connections(self, ret, info):
|
||||
with create_sockets():
|
||||
self.assertEqual(len(ret), len(set(ret)))
|
||||
for conn in ret:
|
||||
assert is_namedtuple(conn)
|
||||
check_connection_ntuple(conn)
|
||||
|
||||
def cwd(self, ret, info):
|
||||
self.assertIsInstance(ret, (str, unicode))
|
||||
self.assertEqual(ret.strip(), ret)
|
||||
if ret:
|
||||
assert os.path.isabs(ret), ret
|
||||
try:
|
||||
st = os.stat(ret)
|
||||
except OSError as err:
|
||||
if WINDOWS and err.errno in \
|
||||
psutil._psplatform.ACCESS_DENIED_SET:
|
||||
pass
|
||||
# directory has been removed in mean time
|
||||
elif err.errno != errno.ENOENT:
|
||||
raise
|
||||
else:
|
||||
assert stat.S_ISDIR(st.st_mode)
|
||||
|
||||
def memory_percent(self, ret, info):
|
||||
self.assertIsInstance(ret, float)
|
||||
assert 0 <= ret <= 100, ret
|
||||
|
||||
def is_running(self, ret, info):
|
||||
self.assertIsInstance(ret, bool)
|
||||
|
||||
def cpu_affinity(self, ret, info):
|
||||
self.assertIsInstance(ret, list)
|
||||
assert ret != [], ret
|
||||
cpus = list(range(psutil.cpu_count()))
|
||||
for n in ret:
|
||||
self.assertIsInstance(n, int)
|
||||
self.assertIn(n, cpus)
|
||||
|
||||
def terminal(self, ret, info):
|
||||
self.assertIsInstance(ret, (str, type(None)))
|
||||
if ret is not None:
|
||||
assert os.path.isabs(ret), ret
|
||||
assert os.path.exists(ret), ret
|
||||
|
||||
def memory_maps(self, ret, info):
|
||||
for nt in ret:
|
||||
self.assertIsInstance(nt.addr, str)
|
||||
self.assertIsInstance(nt.perms, str)
|
||||
self.assertIsInstance(nt.path, str)
|
||||
for fname in nt._fields:
|
||||
value = getattr(nt, fname)
|
||||
if fname == 'path':
|
||||
if not value.startswith(("[", "anon_inode:")):
|
||||
assert os.path.isabs(nt.path), nt.path
|
||||
# commented as on Linux we might get
|
||||
# '/foo/bar (deleted)'
|
||||
# assert os.path.exists(nt.path), nt.path
|
||||
elif fname == 'addr':
|
||||
assert value, repr(value)
|
||||
elif fname == 'perms':
|
||||
if not WINDOWS:
|
||||
assert value, repr(value)
|
||||
else:
|
||||
self.assertIsInstance(value, (int, long))
|
||||
self.assertGreaterEqual(value, 0)
|
||||
|
||||
def num_handles(self, ret, info):
|
||||
self.assertIsInstance(ret, int)
|
||||
self.assertGreaterEqual(ret, 0)
|
||||
|
||||
def nice(self, ret, info):
|
||||
self.assertIsInstance(ret, int)
|
||||
if POSIX:
|
||||
assert -20 <= ret <= 20, ret
|
||||
else:
|
||||
priorities = [getattr(psutil, x) for x in dir(psutil)
|
||||
if x.endswith('_PRIORITY_CLASS')]
|
||||
self.assertIn(ret, priorities)
|
||||
if sys.version_info > (3, 4):
|
||||
self.assertIsInstance(ret, enum.IntEnum)
|
||||
else:
|
||||
self.assertIsInstance(ret, int)
|
||||
|
||||
def num_ctx_switches(self, ret, info):
|
||||
assert is_namedtuple(ret)
|
||||
for value in ret:
|
||||
self.assertIsInstance(value, (int, long))
|
||||
self.assertGreaterEqual(value, 0)
|
||||
|
||||
def rlimit(self, ret, info):
|
||||
self.assertIsInstance(ret, tuple)
|
||||
self.assertEqual(len(ret), 2)
|
||||
self.assertGreaterEqual(ret[0], -1)
|
||||
self.assertGreaterEqual(ret[1], -1)
|
||||
|
||||
def environ(self, ret, info):
|
||||
self.assertIsInstance(ret, dict)
|
||||
for k, v in ret.items():
|
||||
self.assertIsInstance(k, str)
|
||||
self.assertIsInstance(v, str)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,492 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""
|
||||
Tests for detecting function memory leaks (typically the ones
|
||||
implemented in C). It does so by calling a function many times and
|
||||
checking whether process memory usage keeps increasing between
|
||||
calls or over time.
|
||||
Note that this may produce false positives (especially on Windows
|
||||
for some reason).
|
||||
PyPy appears to be completely unstable for this framework, probably
|
||||
because of how its JIT handles memory, so tests are skipped.
|
||||
"""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import functools
|
||||
import os
|
||||
import platform
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
import psutil._common
|
||||
from psutil import LINUX
|
||||
from psutil import MACOS
|
||||
from psutil import OPENBSD
|
||||
from psutil import POSIX
|
||||
from psutil import SUNOS
|
||||
from psutil import WINDOWS
|
||||
from psutil._compat import ProcessLookupError
|
||||
from psutil._compat import super
|
||||
from psutil.tests import HAS_CPU_AFFINITY
|
||||
from psutil.tests import HAS_CPU_FREQ
|
||||
from psutil.tests import HAS_ENVIRON
|
||||
from psutil.tests import HAS_IONICE
|
||||
from psutil.tests import HAS_MEMORY_MAPS
|
||||
from psutil.tests import HAS_NET_IO_COUNTERS
|
||||
from psutil.tests import HAS_PROC_CPU_NUM
|
||||
from psutil.tests import HAS_PROC_IO_COUNTERS
|
||||
from psutil.tests import HAS_RLIMIT
|
||||
from psutil.tests import HAS_SENSORS_BATTERY
|
||||
from psutil.tests import HAS_SENSORS_FANS
|
||||
from psutil.tests import HAS_SENSORS_TEMPERATURES
|
||||
from psutil.tests import TestMemoryLeak
|
||||
from psutil.tests import create_sockets
|
||||
from psutil.tests import get_testfn
|
||||
from psutil.tests import process_namespace
|
||||
from psutil.tests import skip_on_access_denied
|
||||
from psutil.tests import spawn_testproc
|
||||
from psutil.tests import system_namespace
|
||||
from psutil.tests import terminate
|
||||
|
||||
|
||||
cext = psutil._psplatform.cext
|
||||
thisproc = psutil.Process()
|
||||
FEW_TIMES = 5
|
||||
|
||||
|
||||
def fewtimes_if_linux():
|
||||
"""Decorator for those Linux functions which are implemented in pure
|
||||
Python, and which we want to run faster.
|
||||
"""
|
||||
def decorator(fun):
|
||||
@functools.wraps(fun)
|
||||
def wrapper(self, *args, **kwargs):
|
||||
if LINUX:
|
||||
before = self.__class__.times
|
||||
try:
|
||||
self.__class__.times = FEW_TIMES
|
||||
return fun(self, *args, **kwargs)
|
||||
finally:
|
||||
self.__class__.times = before
|
||||
else:
|
||||
return fun(self, *args, **kwargs)
|
||||
return wrapper
|
||||
return decorator
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# Process class
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestProcessObjectLeaks(TestMemoryLeak):
|
||||
"""Test leaks of Process class methods."""
|
||||
|
||||
proc = thisproc
|
||||
|
||||
def test_coverage(self):
|
||||
ns = process_namespace(None)
|
||||
ns.test_class_coverage(self, ns.getters + ns.setters)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_name(self):
|
||||
self.execute(self.proc.name)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_cmdline(self):
|
||||
self.execute(self.proc.cmdline)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_exe(self):
|
||||
self.execute(self.proc.exe)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_ppid(self):
|
||||
self.execute(self.proc.ppid)
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
@fewtimes_if_linux()
|
||||
def test_uids(self):
|
||||
self.execute(self.proc.uids)
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
@fewtimes_if_linux()
|
||||
def test_gids(self):
|
||||
self.execute(self.proc.gids)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_status(self):
|
||||
self.execute(self.proc.status)
|
||||
|
||||
def test_nice(self):
|
||||
self.execute(self.proc.nice)
|
||||
|
||||
def test_nice_set(self):
|
||||
niceness = thisproc.nice()
|
||||
self.execute(lambda: self.proc.nice(niceness))
|
||||
|
||||
@unittest.skipIf(not HAS_IONICE, "not supported")
|
||||
def test_ionice(self):
|
||||
self.execute(self.proc.ionice)
|
||||
|
||||
@unittest.skipIf(not HAS_IONICE, "not supported")
|
||||
def test_ionice_set(self):
|
||||
if WINDOWS:
|
||||
value = thisproc.ionice()
|
||||
self.execute(lambda: self.proc.ionice(value))
|
||||
else:
|
||||
self.execute(lambda: self.proc.ionice(psutil.IOPRIO_CLASS_NONE))
|
||||
fun = functools.partial(cext.proc_ioprio_set, os.getpid(), -1, 0)
|
||||
self.execute_w_exc(OSError, fun)
|
||||
|
||||
@unittest.skipIf(not HAS_PROC_IO_COUNTERS, "not supported")
|
||||
@fewtimes_if_linux()
|
||||
def test_io_counters(self):
|
||||
self.execute(self.proc.io_counters)
|
||||
|
||||
@unittest.skipIf(POSIX, "worthless on POSIX")
|
||||
def test_username(self):
|
||||
# always open 1 handle on Windows (only once)
|
||||
psutil.Process().username()
|
||||
self.execute(self.proc.username)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_create_time(self):
|
||||
self.execute(self.proc.create_time)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@skip_on_access_denied(only_if=OPENBSD)
|
||||
def test_num_threads(self):
|
||||
self.execute(self.proc.num_threads)
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
def test_num_handles(self):
|
||||
self.execute(self.proc.num_handles)
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
@fewtimes_if_linux()
|
||||
def test_num_fds(self):
|
||||
self.execute(self.proc.num_fds)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_num_ctx_switches(self):
|
||||
self.execute(self.proc.num_ctx_switches)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@skip_on_access_denied(only_if=OPENBSD)
|
||||
def test_threads(self):
|
||||
self.execute(self.proc.threads)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_cpu_times(self):
|
||||
self.execute(self.proc.cpu_times)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@unittest.skipIf(not HAS_PROC_CPU_NUM, "not supported")
|
||||
def test_cpu_num(self):
|
||||
self.execute(self.proc.cpu_num)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_memory_info(self):
|
||||
self.execute(self.proc.memory_info)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_memory_full_info(self):
|
||||
self.execute(self.proc.memory_full_info)
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
@fewtimes_if_linux()
|
||||
def test_terminal(self):
|
||||
self.execute(self.proc.terminal)
|
||||
|
||||
def test_resume(self):
|
||||
times = FEW_TIMES if POSIX else self.times
|
||||
self.execute(self.proc.resume, times=times)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_cwd(self):
|
||||
self.execute(self.proc.cwd)
|
||||
|
||||
@unittest.skipIf(not HAS_CPU_AFFINITY, "not supported")
|
||||
def test_cpu_affinity(self):
|
||||
self.execute(self.proc.cpu_affinity)
|
||||
|
||||
@unittest.skipIf(not HAS_CPU_AFFINITY, "not supported")
|
||||
def test_cpu_affinity_set(self):
|
||||
affinity = thisproc.cpu_affinity()
|
||||
self.execute(lambda: self.proc.cpu_affinity(affinity))
|
||||
self.execute_w_exc(
|
||||
ValueError, lambda: self.proc.cpu_affinity([-1]))
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_open_files(self):
|
||||
with open(get_testfn(), 'w'):
|
||||
self.execute(self.proc.open_files)
|
||||
|
||||
@unittest.skipIf(not HAS_MEMORY_MAPS, "not supported")
|
||||
@fewtimes_if_linux()
|
||||
def test_memory_maps(self):
|
||||
self.execute(self.proc.memory_maps)
|
||||
|
||||
@unittest.skipIf(not LINUX, "LINUX only")
|
||||
@unittest.skipIf(not HAS_RLIMIT, "not supported")
|
||||
def test_rlimit(self):
|
||||
self.execute(lambda: self.proc.rlimit(psutil.RLIMIT_NOFILE))
|
||||
|
||||
@unittest.skipIf(not LINUX, "LINUX only")
|
||||
@unittest.skipIf(not HAS_RLIMIT, "not supported")
|
||||
def test_rlimit_set(self):
|
||||
limit = thisproc.rlimit(psutil.RLIMIT_NOFILE)
|
||||
self.execute(lambda: self.proc.rlimit(psutil.RLIMIT_NOFILE, limit))
|
||||
self.execute_w_exc((OSError, ValueError), lambda: self.proc.rlimit(-1))
|
||||
|
||||
@fewtimes_if_linux()
|
||||
# Windows implementation is based on a single system-wide
|
||||
# function (tested later).
|
||||
@unittest.skipIf(WINDOWS, "worthless on WINDOWS")
|
||||
def test_connections(self):
|
||||
# TODO: UNIX sockets are temporarily implemented by parsing
|
||||
# 'pfiles' cmd output; we don't want that part of the code to
|
||||
# be executed.
|
||||
with create_sockets():
|
||||
kind = 'inet' if SUNOS else 'all'
|
||||
self.execute(lambda: self.proc.connections(kind))
|
||||
|
||||
@unittest.skipIf(not HAS_ENVIRON, "not supported")
|
||||
def test_environ(self):
|
||||
self.execute(self.proc.environ)
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
def test_proc_info(self):
|
||||
self.execute(lambda: cext.proc_info(os.getpid()))
|
||||
|
||||
|
||||
class TestTerminatedProcessLeaks(TestProcessObjectLeaks):
|
||||
"""Repeat the tests above looking for leaks occurring when dealing
|
||||
with terminated processes raising NoSuchProcess exception.
|
||||
The C functions are still invoked but will follow different code
|
||||
paths. We'll check those code paths.
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
cls.subp = spawn_testproc()
|
||||
cls.proc = psutil.Process(cls.subp.pid)
|
||||
cls.proc.kill()
|
||||
cls.proc.wait()
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
super().tearDownClass()
|
||||
terminate(cls.subp)
|
||||
|
||||
def call(self, fun):
|
||||
try:
|
||||
fun()
|
||||
except psutil.NoSuchProcess:
|
||||
pass
|
||||
|
||||
if WINDOWS:
|
||||
|
||||
def test_kill(self):
|
||||
self.execute(self.proc.kill)
|
||||
|
||||
def test_terminate(self):
|
||||
self.execute(self.proc.terminate)
|
||||
|
||||
def test_suspend(self):
|
||||
self.execute(self.proc.suspend)
|
||||
|
||||
def test_resume(self):
|
||||
self.execute(self.proc.resume)
|
||||
|
||||
def test_wait(self):
|
||||
self.execute(self.proc.wait)
|
||||
|
||||
def test_proc_info(self):
|
||||
# test dual implementation
|
||||
def call():
|
||||
try:
|
||||
return cext.proc_info(self.proc.pid)
|
||||
except ProcessLookupError:
|
||||
pass
|
||||
|
||||
self.execute(call)
|
||||
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
class TestProcessDualImplementation(TestMemoryLeak):
|
||||
|
||||
def test_cmdline_peb_true(self):
|
||||
self.execute(lambda: cext.proc_cmdline(os.getpid(), use_peb=True))
|
||||
|
||||
def test_cmdline_peb_false(self):
|
||||
self.execute(lambda: cext.proc_cmdline(os.getpid(), use_peb=False))
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# system APIs
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestModuleFunctionsLeaks(TestMemoryLeak):
|
||||
"""Test leaks of psutil module functions."""
|
||||
|
||||
def test_coverage(self):
|
||||
ns = system_namespace()
|
||||
ns.test_class_coverage(self, ns.all)
|
||||
|
||||
# --- cpu
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_cpu_count(self): # logical
|
||||
self.execute(lambda: psutil.cpu_count(logical=True))
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_cpu_count_cores(self):
|
||||
self.execute(lambda: psutil.cpu_count(logical=False))
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_cpu_times(self):
|
||||
self.execute(psutil.cpu_times)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_per_cpu_times(self):
|
||||
self.execute(lambda: psutil.cpu_times(percpu=True))
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_cpu_stats(self):
|
||||
self.execute(psutil.cpu_stats)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
# TODO: remove this once 1892 is fixed
|
||||
@unittest.skipIf(MACOS and platform.machine() == 'arm64',
|
||||
"skipped due to #1892")
|
||||
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
|
||||
def test_cpu_freq(self):
|
||||
self.execute(psutil.cpu_freq)
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
def test_getloadavg(self):
|
||||
psutil.getloadavg()
|
||||
self.execute(psutil.getloadavg)
|
||||
|
||||
# --- mem
|
||||
|
||||
def test_virtual_memory(self):
|
||||
self.execute(psutil.virtual_memory)
|
||||
|
||||
# TODO: remove this skip when this gets fixed
|
||||
@unittest.skipIf(SUNOS, "worthless on SUNOS (uses a subprocess)")
|
||||
def test_swap_memory(self):
|
||||
self.execute(psutil.swap_memory)
|
||||
|
||||
def test_pid_exists(self):
|
||||
times = FEW_TIMES if POSIX else self.times
|
||||
self.execute(lambda: psutil.pid_exists(os.getpid()), times=times)
|
||||
|
||||
# --- disk
|
||||
|
||||
def test_disk_usage(self):
|
||||
times = FEW_TIMES if POSIX else self.times
|
||||
self.execute(lambda: psutil.disk_usage('.'), times=times)
|
||||
|
||||
def test_disk_partitions(self):
|
||||
self.execute(psutil.disk_partitions)
|
||||
|
||||
@unittest.skipIf(LINUX and not os.path.exists('/proc/diskstats'),
|
||||
'/proc/diskstats not available on this Linux version')
|
||||
@fewtimes_if_linux()
|
||||
def test_disk_io_counters(self):
|
||||
self.execute(lambda: psutil.disk_io_counters(nowrap=False))
|
||||
|
||||
# --- proc
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_pids(self):
|
||||
self.execute(psutil.pids)
|
||||
|
||||
# --- net
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@unittest.skipIf(not HAS_NET_IO_COUNTERS, 'not supported')
|
||||
def test_net_io_counters(self):
|
||||
self.execute(lambda: psutil.net_io_counters(nowrap=False))
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@unittest.skipIf(MACOS and os.getuid() != 0, "need root access")
|
||||
def test_net_connections(self):
|
||||
# always opens and handle on Windows() (once)
|
||||
psutil.net_connections(kind='all')
|
||||
with create_sockets():
|
||||
self.execute(lambda: psutil.net_connections(kind='all'))
|
||||
|
||||
def test_net_if_addrs(self):
|
||||
# Note: verified that on Windows this was a false positive.
|
||||
tolerance = 80 * 1024 if WINDOWS else self.tolerance
|
||||
self.execute(psutil.net_if_addrs, tolerance=tolerance)
|
||||
|
||||
def test_net_if_stats(self):
|
||||
self.execute(psutil.net_if_stats)
|
||||
|
||||
# --- sensors
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@unittest.skipIf(not HAS_SENSORS_BATTERY, "not supported")
|
||||
def test_sensors_battery(self):
|
||||
self.execute(psutil.sensors_battery)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@unittest.skipIf(not HAS_SENSORS_TEMPERATURES, "not supported")
|
||||
def test_sensors_temperatures(self):
|
||||
self.execute(psutil.sensors_temperatures)
|
||||
|
||||
@fewtimes_if_linux()
|
||||
@unittest.skipIf(not HAS_SENSORS_FANS, "not supported")
|
||||
def test_sensors_fans(self):
|
||||
self.execute(psutil.sensors_fans)
|
||||
|
||||
# --- others
|
||||
|
||||
@fewtimes_if_linux()
|
||||
def test_boot_time(self):
|
||||
self.execute(psutil.boot_time)
|
||||
|
||||
def test_users(self):
|
||||
self.execute(psutil.users)
|
||||
|
||||
def test_set_debug(self):
|
||||
self.execute(lambda: psutil._set_debug(False))
|
||||
|
||||
if WINDOWS:
|
||||
|
||||
# --- win services
|
||||
|
||||
def test_win_service_iter(self):
|
||||
self.execute(cext.winservice_enumerate)
|
||||
|
||||
def test_win_service_get(self):
|
||||
pass
|
||||
|
||||
def test_win_service_get_config(self):
|
||||
name = next(psutil.win_service_iter()).name()
|
||||
self.execute(lambda: cext.winservice_query_config(name))
|
||||
|
||||
def test_win_service_get_status(self):
|
||||
name = next(psutil.win_service_iter()).name()
|
||||
self.execute(lambda: cext.winservice_query_status(name))
|
||||
|
||||
def test_win_service_get_description(self):
|
||||
name = next(psutil.win_service_iter()).name()
|
||||
self.execute(lambda: cext.winservice_query_descr(name))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,954 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# 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.
|
||||
|
||||
"""
|
||||
Miscellaneous tests.
|
||||
"""
|
||||
|
||||
import ast
|
||||
import collections
|
||||
import errno
|
||||
import json
|
||||
import os
|
||||
import pickle
|
||||
import socket
|
||||
import stat
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
import psutil.tests
|
||||
from psutil import LINUX
|
||||
from psutil import POSIX
|
||||
from psutil import WINDOWS
|
||||
from psutil._common import bcat
|
||||
from psutil._common import cat
|
||||
from psutil._common import debug
|
||||
from psutil._common import isfile_strict
|
||||
from psutil._common import memoize
|
||||
from psutil._common import memoize_when_activated
|
||||
from psutil._common import parse_environ_block
|
||||
from psutil._common import supports_ipv6
|
||||
from psutil._common import wrap_numbers
|
||||
from psutil._compat import PY3
|
||||
from psutil._compat import FileNotFoundError
|
||||
from psutil._compat import redirect_stderr
|
||||
from psutil.tests import APPVEYOR
|
||||
from psutil.tests import CI_TESTING
|
||||
from psutil.tests import HAS_BATTERY
|
||||
from psutil.tests import HAS_MEMORY_MAPS
|
||||
from psutil.tests import HAS_NET_IO_COUNTERS
|
||||
from psutil.tests import HAS_SENSORS_BATTERY
|
||||
from psutil.tests import HAS_SENSORS_FANS
|
||||
from psutil.tests import HAS_SENSORS_TEMPERATURES
|
||||
from psutil.tests import PYTHON_EXE
|
||||
from psutil.tests import PYTHON_EXE_ENV
|
||||
from psutil.tests import SCRIPTS_DIR
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import mock
|
||||
from psutil.tests import reload_module
|
||||
from psutil.tests import sh
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- Test classes' repr(), str(), ...
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestSpecialMethods(PsutilTestCase):
|
||||
|
||||
def test_process__repr__(self, func=repr):
|
||||
p = psutil.Process(self.spawn_testproc().pid)
|
||||
r = func(p)
|
||||
self.assertIn("psutil.Process", r)
|
||||
self.assertIn("pid=%s" % p.pid, r)
|
||||
self.assertIn("name='%s'" % str(p.name()),
|
||||
r.replace("name=u'", "name='"))
|
||||
self.assertIn("status=", r)
|
||||
self.assertNotIn("exitcode=", r)
|
||||
p.terminate()
|
||||
p.wait()
|
||||
r = func(p)
|
||||
self.assertIn("status='terminated'", r)
|
||||
self.assertIn("exitcode=", r)
|
||||
|
||||
with mock.patch.object(psutil.Process, "name",
|
||||
side_effect=psutil.ZombieProcess(os.getpid())):
|
||||
p = psutil.Process()
|
||||
r = func(p)
|
||||
self.assertIn("pid=%s" % p.pid, r)
|
||||
self.assertIn("status='zombie'", r)
|
||||
self.assertNotIn("name=", r)
|
||||
with mock.patch.object(psutil.Process, "name",
|
||||
side_effect=psutil.NoSuchProcess(os.getpid())):
|
||||
p = psutil.Process()
|
||||
r = func(p)
|
||||
self.assertIn("pid=%s" % p.pid, r)
|
||||
self.assertIn("terminated", r)
|
||||
self.assertNotIn("name=", r)
|
||||
with mock.patch.object(psutil.Process, "name",
|
||||
side_effect=psutil.AccessDenied(os.getpid())):
|
||||
p = psutil.Process()
|
||||
r = func(p)
|
||||
self.assertIn("pid=%s" % p.pid, r)
|
||||
self.assertNotIn("name=", r)
|
||||
|
||||
def test_process__str__(self):
|
||||
self.test_process__repr__(func=str)
|
||||
|
||||
def test_error__repr__(self):
|
||||
self.assertEqual(repr(psutil.Error()), "psutil.Error()")
|
||||
|
||||
def test_error__str__(self):
|
||||
self.assertEqual(str(psutil.Error()), "")
|
||||
|
||||
def test_no_such_process__repr__(self):
|
||||
self.assertEqual(
|
||||
repr(psutil.NoSuchProcess(321)),
|
||||
"psutil.NoSuchProcess(pid=321, msg='process no longer exists')")
|
||||
self.assertEqual(
|
||||
repr(psutil.NoSuchProcess(321, name="name", msg="msg")),
|
||||
"psutil.NoSuchProcess(pid=321, name='name', msg='msg')")
|
||||
|
||||
def test_no_such_process__str__(self):
|
||||
self.assertEqual(
|
||||
str(psutil.NoSuchProcess(321)),
|
||||
"process no longer exists (pid=321)")
|
||||
self.assertEqual(
|
||||
str(psutil.NoSuchProcess(321, name="name", msg="msg")),
|
||||
"msg (pid=321, name='name')")
|
||||
|
||||
def test_zombie_process__repr__(self):
|
||||
self.assertEqual(
|
||||
repr(psutil.ZombieProcess(321)),
|
||||
'psutil.ZombieProcess(pid=321, msg="PID still '
|
||||
'exists but it\'s a zombie")')
|
||||
self.assertEqual(
|
||||
repr(psutil.ZombieProcess(321, name="name", ppid=320, msg="foo")),
|
||||
"psutil.ZombieProcess(pid=321, ppid=320, name='name', msg='foo')")
|
||||
|
||||
def test_zombie_process__str__(self):
|
||||
self.assertEqual(
|
||||
str(psutil.ZombieProcess(321)),
|
||||
"PID still exists but it's a zombie (pid=321)")
|
||||
self.assertEqual(
|
||||
str(psutil.ZombieProcess(321, name="name", ppid=320, msg="foo")),
|
||||
"foo (pid=321, ppid=320, name='name')")
|
||||
|
||||
def test_access_denied__repr__(self):
|
||||
self.assertEqual(
|
||||
repr(psutil.AccessDenied(321)),
|
||||
"psutil.AccessDenied(pid=321)")
|
||||
self.assertEqual(
|
||||
repr(psutil.AccessDenied(321, name="name", msg="msg")),
|
||||
"psutil.AccessDenied(pid=321, name='name', msg='msg')")
|
||||
|
||||
def test_access_denied__str__(self):
|
||||
self.assertEqual(
|
||||
str(psutil.AccessDenied(321)),
|
||||
"(pid=321)")
|
||||
self.assertEqual(
|
||||
str(psutil.AccessDenied(321, name="name", msg="msg")),
|
||||
"msg (pid=321, name='name')")
|
||||
|
||||
def test_timeout_expired__repr__(self):
|
||||
self.assertEqual(
|
||||
repr(psutil.TimeoutExpired(5)),
|
||||
"psutil.TimeoutExpired(seconds=5, msg='timeout after 5 seconds')")
|
||||
self.assertEqual(
|
||||
repr(psutil.TimeoutExpired(5, pid=321, name="name")),
|
||||
"psutil.TimeoutExpired(pid=321, name='name', seconds=5, "
|
||||
"msg='timeout after 5 seconds')")
|
||||
|
||||
def test_timeout_expired__str__(self):
|
||||
self.assertEqual(
|
||||
str(psutil.TimeoutExpired(5)),
|
||||
"timeout after 5 seconds")
|
||||
self.assertEqual(
|
||||
str(psutil.TimeoutExpired(5, pid=321, name="name")),
|
||||
"timeout after 5 seconds (pid=321, name='name')")
|
||||
|
||||
def test_process__eq__(self):
|
||||
p1 = psutil.Process()
|
||||
p2 = psutil.Process()
|
||||
self.assertEqual(p1, p2)
|
||||
p2._ident = (0, 0)
|
||||
self.assertNotEqual(p1, p2)
|
||||
self.assertNotEqual(p1, 'foo')
|
||||
|
||||
def test_process__hash__(self):
|
||||
s = set([psutil.Process(), psutil.Process()])
|
||||
self.assertEqual(len(s), 1)
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- Misc, generic, corner cases
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestMisc(PsutilTestCase):
|
||||
|
||||
def test__all__(self):
|
||||
dir_psutil = dir(psutil)
|
||||
for name in dir_psutil:
|
||||
if name in ('long', 'tests', 'test', 'PermissionError',
|
||||
'ProcessLookupError'):
|
||||
continue
|
||||
if not name.startswith('_'):
|
||||
try:
|
||||
__import__(name)
|
||||
except ImportError:
|
||||
if name not in psutil.__all__:
|
||||
fun = getattr(psutil, name)
|
||||
if fun is None:
|
||||
continue
|
||||
if (fun.__doc__ is not None and
|
||||
'deprecated' not in fun.__doc__.lower()):
|
||||
raise self.fail('%r not in psutil.__all__' % name)
|
||||
|
||||
# Import 'star' will break if __all__ is inconsistent, see:
|
||||
# https://github.com/giampaolo/psutil/issues/656
|
||||
# Can't do `from psutil import *` as it won't work on python 3
|
||||
# so we simply iterate over __all__.
|
||||
for name in psutil.__all__:
|
||||
self.assertIn(name, dir_psutil)
|
||||
|
||||
def test_version(self):
|
||||
self.assertEqual('.'.join([str(x) for x in psutil.version_info]),
|
||||
psutil.__version__)
|
||||
|
||||
def test_process_as_dict_no_new_names(self):
|
||||
# See https://github.com/giampaolo/psutil/issues/813
|
||||
p = psutil.Process()
|
||||
p.foo = '1'
|
||||
self.assertNotIn('foo', p.as_dict())
|
||||
|
||||
def test_serialization(self):
|
||||
def check(ret):
|
||||
if json is not None:
|
||||
json.loads(json.dumps(ret))
|
||||
a = pickle.dumps(ret)
|
||||
b = pickle.loads(a)
|
||||
self.assertEqual(ret, b)
|
||||
|
||||
check(psutil.Process().as_dict())
|
||||
check(psutil.virtual_memory())
|
||||
check(psutil.swap_memory())
|
||||
check(psutil.cpu_times())
|
||||
check(psutil.cpu_times_percent(interval=0))
|
||||
check(psutil.net_io_counters())
|
||||
if LINUX and not os.path.exists('/proc/diskstats'):
|
||||
pass
|
||||
else:
|
||||
if not APPVEYOR:
|
||||
check(psutil.disk_io_counters())
|
||||
check(psutil.disk_partitions())
|
||||
check(psutil.disk_usage(os.getcwd()))
|
||||
check(psutil.users())
|
||||
|
||||
# # XXX: https://github.com/pypa/setuptools/pull/2896
|
||||
# @unittest.skipIf(APPVEYOR, "temporarily disabled due to setuptools bug")
|
||||
# def test_setup_script(self):
|
||||
# setup_py = os.path.join(ROOT_DIR, 'setup.py')
|
||||
# if CI_TESTING and not os.path.exists(setup_py):
|
||||
# return self.skipTest("can't find setup.py")
|
||||
# module = import_module_by_path(setup_py)
|
||||
# self.assertRaises(SystemExit, module.setup)
|
||||
# self.assertEqual(module.get_version(), psutil.__version__)
|
||||
|
||||
def test_ad_on_process_creation(self):
|
||||
# We are supposed to be able to instantiate Process also in case
|
||||
# of zombie processes or access denied.
|
||||
with mock.patch.object(psutil.Process, 'create_time',
|
||||
side_effect=psutil.AccessDenied) as meth:
|
||||
psutil.Process()
|
||||
assert meth.called
|
||||
with mock.patch.object(psutil.Process, 'create_time',
|
||||
side_effect=psutil.ZombieProcess(1)) as meth:
|
||||
psutil.Process()
|
||||
assert meth.called
|
||||
with mock.patch.object(psutil.Process, 'create_time',
|
||||
side_effect=ValueError) as meth:
|
||||
with self.assertRaises(ValueError):
|
||||
psutil.Process()
|
||||
assert meth.called
|
||||
|
||||
def test_sanity_version_check(self):
|
||||
# see: https://github.com/giampaolo/psutil/issues/564
|
||||
with mock.patch(
|
||||
"psutil._psplatform.cext.version", return_value="0.0.0"):
|
||||
with self.assertRaises(ImportError) as cm:
|
||||
reload_module(psutil)
|
||||
self.assertIn("version conflict", str(cm.exception).lower())
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- psutil/_common.py utils
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestMemoizeDecorator(PsutilTestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.calls = []
|
||||
|
||||
tearDown = setUp
|
||||
|
||||
def run_against(self, obj, expected_retval=None):
|
||||
# no args
|
||||
for _ in range(2):
|
||||
ret = obj()
|
||||
self.assertEqual(self.calls, [((), {})])
|
||||
if expected_retval is not None:
|
||||
self.assertEqual(ret, expected_retval)
|
||||
# with args
|
||||
for _ in range(2):
|
||||
ret = obj(1)
|
||||
self.assertEqual(self.calls, [((), {}), ((1, ), {})])
|
||||
if expected_retval is not None:
|
||||
self.assertEqual(ret, expected_retval)
|
||||
# with args + kwargs
|
||||
for _ in range(2):
|
||||
ret = obj(1, bar=2)
|
||||
self.assertEqual(
|
||||
self.calls, [((), {}), ((1, ), {}), ((1, ), {'bar': 2})])
|
||||
if expected_retval is not None:
|
||||
self.assertEqual(ret, expected_retval)
|
||||
# clear cache
|
||||
self.assertEqual(len(self.calls), 3)
|
||||
obj.cache_clear()
|
||||
ret = obj()
|
||||
if expected_retval is not None:
|
||||
self.assertEqual(ret, expected_retval)
|
||||
self.assertEqual(len(self.calls), 4)
|
||||
# docstring
|
||||
self.assertEqual(obj.__doc__, "my docstring")
|
||||
|
||||
def test_function(self):
|
||||
@memoize
|
||||
def foo(*args, **kwargs):
|
||||
"""my docstring"""
|
||||
baseclass.calls.append((args, kwargs))
|
||||
return 22
|
||||
|
||||
baseclass = self
|
||||
self.run_against(foo, expected_retval=22)
|
||||
|
||||
def test_class(self):
|
||||
@memoize
|
||||
class Foo:
|
||||
"""my docstring"""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
baseclass.calls.append((args, kwargs))
|
||||
|
||||
def bar(self):
|
||||
return 22
|
||||
|
||||
baseclass = self
|
||||
self.run_against(Foo, expected_retval=None)
|
||||
self.assertEqual(Foo().bar(), 22)
|
||||
|
||||
def test_class_singleton(self):
|
||||
# @memoize can be used against classes to create singletons
|
||||
@memoize
|
||||
class Bar:
|
||||
def __init__(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
self.assertIs(Bar(), Bar())
|
||||
self.assertEqual(id(Bar()), id(Bar()))
|
||||
self.assertEqual(id(Bar(1)), id(Bar(1)))
|
||||
self.assertEqual(id(Bar(1, foo=3)), id(Bar(1, foo=3)))
|
||||
self.assertNotEqual(id(Bar(1)), id(Bar(2)))
|
||||
|
||||
def test_staticmethod(self):
|
||||
class Foo:
|
||||
@staticmethod
|
||||
@memoize
|
||||
def bar(*args, **kwargs):
|
||||
"""my docstring"""
|
||||
baseclass.calls.append((args, kwargs))
|
||||
return 22
|
||||
|
||||
baseclass = self
|
||||
self.run_against(Foo().bar, expected_retval=22)
|
||||
|
||||
def test_classmethod(self):
|
||||
class Foo:
|
||||
@classmethod
|
||||
@memoize
|
||||
def bar(cls, *args, **kwargs):
|
||||
"""my docstring"""
|
||||
baseclass.calls.append((args, kwargs))
|
||||
return 22
|
||||
|
||||
baseclass = self
|
||||
self.run_against(Foo().bar, expected_retval=22)
|
||||
|
||||
def test_original(self):
|
||||
# This was the original test before I made it dynamic to test it
|
||||
# against different types. Keeping it anyway.
|
||||
@memoize
|
||||
def foo(*args, **kwargs):
|
||||
"""foo docstring"""
|
||||
calls.append(None)
|
||||
return (args, kwargs)
|
||||
|
||||
calls = []
|
||||
# no args
|
||||
for _ in range(2):
|
||||
ret = foo()
|
||||
expected = ((), {})
|
||||
self.assertEqual(ret, expected)
|
||||
self.assertEqual(len(calls), 1)
|
||||
# with args
|
||||
for _ in range(2):
|
||||
ret = foo(1)
|
||||
expected = ((1, ), {})
|
||||
self.assertEqual(ret, expected)
|
||||
self.assertEqual(len(calls), 2)
|
||||
# with args + kwargs
|
||||
for _ in range(2):
|
||||
ret = foo(1, bar=2)
|
||||
expected = ((1, ), {'bar': 2})
|
||||
self.assertEqual(ret, expected)
|
||||
self.assertEqual(len(calls), 3)
|
||||
# clear cache
|
||||
foo.cache_clear()
|
||||
ret = foo()
|
||||
expected = ((), {})
|
||||
self.assertEqual(ret, expected)
|
||||
self.assertEqual(len(calls), 4)
|
||||
# docstring
|
||||
self.assertEqual(foo.__doc__, "foo docstring")
|
||||
|
||||
|
||||
class TestCommonModule(PsutilTestCase):
|
||||
|
||||
def test_memoize_when_activated(self):
|
||||
class Foo:
|
||||
|
||||
@memoize_when_activated
|
||||
def foo(self):
|
||||
calls.append(None)
|
||||
|
||||
f = Foo()
|
||||
calls = []
|
||||
f.foo()
|
||||
f.foo()
|
||||
self.assertEqual(len(calls), 2)
|
||||
|
||||
# activate
|
||||
calls = []
|
||||
f.foo.cache_activate(f)
|
||||
f.foo()
|
||||
f.foo()
|
||||
self.assertEqual(len(calls), 1)
|
||||
|
||||
# deactivate
|
||||
calls = []
|
||||
f.foo.cache_deactivate(f)
|
||||
f.foo()
|
||||
f.foo()
|
||||
self.assertEqual(len(calls), 2)
|
||||
|
||||
def test_parse_environ_block(self):
|
||||
def k(s):
|
||||
return s.upper() if WINDOWS else s
|
||||
|
||||
self.assertEqual(parse_environ_block("a=1\0"),
|
||||
{k("a"): "1"})
|
||||
self.assertEqual(parse_environ_block("a=1\0b=2\0\0"),
|
||||
{k("a"): "1", k("b"): "2"})
|
||||
self.assertEqual(parse_environ_block("a=1\0b=\0\0"),
|
||||
{k("a"): "1", k("b"): ""})
|
||||
# ignore everything after \0\0
|
||||
self.assertEqual(parse_environ_block("a=1\0b=2\0\0c=3\0"),
|
||||
{k("a"): "1", k("b"): "2"})
|
||||
# ignore everything that is not an assignment
|
||||
self.assertEqual(parse_environ_block("xxx\0a=1\0"), {k("a"): "1"})
|
||||
self.assertEqual(parse_environ_block("a=1\0=b=2\0"), {k("a"): "1"})
|
||||
# do not fail if the block is incomplete
|
||||
self.assertEqual(parse_environ_block("a=1\0b=2"), {k("a"): "1"})
|
||||
|
||||
def test_supports_ipv6(self):
|
||||
self.addCleanup(supports_ipv6.cache_clear)
|
||||
if supports_ipv6():
|
||||
with mock.patch('psutil._common.socket') as s:
|
||||
s.has_ipv6 = False
|
||||
supports_ipv6.cache_clear()
|
||||
assert not supports_ipv6()
|
||||
|
||||
supports_ipv6.cache_clear()
|
||||
with mock.patch('psutil._common.socket.socket',
|
||||
side_effect=socket.error) as s:
|
||||
assert not supports_ipv6()
|
||||
assert s.called
|
||||
|
||||
supports_ipv6.cache_clear()
|
||||
with mock.patch('psutil._common.socket.socket',
|
||||
side_effect=socket.gaierror) as s:
|
||||
assert not supports_ipv6()
|
||||
supports_ipv6.cache_clear()
|
||||
assert s.called
|
||||
|
||||
supports_ipv6.cache_clear()
|
||||
with mock.patch('psutil._common.socket.socket.bind',
|
||||
side_effect=socket.gaierror) as s:
|
||||
assert not supports_ipv6()
|
||||
supports_ipv6.cache_clear()
|
||||
assert s.called
|
||||
else:
|
||||
with self.assertRaises(socket.error):
|
||||
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
|
||||
try:
|
||||
sock.bind(("::1", 0))
|
||||
finally:
|
||||
sock.close()
|
||||
|
||||
def test_isfile_strict(self):
|
||||
this_file = os.path.abspath(__file__)
|
||||
assert isfile_strict(this_file)
|
||||
assert not isfile_strict(os.path.dirname(this_file))
|
||||
with mock.patch('psutil._common.os.stat',
|
||||
side_effect=OSError(errno.EPERM, "foo")):
|
||||
self.assertRaises(OSError, isfile_strict, this_file)
|
||||
with mock.patch('psutil._common.os.stat',
|
||||
side_effect=OSError(errno.EACCES, "foo")):
|
||||
self.assertRaises(OSError, isfile_strict, this_file)
|
||||
with mock.patch('psutil._common.os.stat',
|
||||
side_effect=OSError(errno.ENOENT, "foo")):
|
||||
assert not isfile_strict(this_file)
|
||||
with mock.patch('psutil._common.stat.S_ISREG', return_value=False):
|
||||
assert not isfile_strict(this_file)
|
||||
|
||||
def test_debug(self):
|
||||
if PY3:
|
||||
from io import StringIO
|
||||
else:
|
||||
from StringIO import StringIO
|
||||
|
||||
with redirect_stderr(StringIO()) as f:
|
||||
debug("hello")
|
||||
msg = f.getvalue()
|
||||
assert msg.startswith("psutil-debug"), msg
|
||||
self.assertIn("hello", msg)
|
||||
self.assertIn(__file__.replace('.pyc', '.py'), msg)
|
||||
|
||||
# supposed to use repr(exc)
|
||||
with redirect_stderr(StringIO()) as f:
|
||||
debug(ValueError("this is an error"))
|
||||
msg = f.getvalue()
|
||||
self.assertIn("ignoring ValueError", msg)
|
||||
self.assertIn("'this is an error'", msg)
|
||||
|
||||
# supposed to use str(exc), because of extra info about file name
|
||||
with redirect_stderr(StringIO()) as f:
|
||||
exc = OSError(2, "no such file")
|
||||
exc.filename = "/foo"
|
||||
debug(exc)
|
||||
msg = f.getvalue()
|
||||
self.assertIn("no such file", msg)
|
||||
self.assertIn("/foo", msg)
|
||||
|
||||
def test_cat_bcat(self):
|
||||
testfn = self.get_testfn()
|
||||
with open(testfn, "wt") as f:
|
||||
f.write("foo")
|
||||
self.assertEqual(cat(testfn), "foo")
|
||||
self.assertEqual(bcat(testfn), b"foo")
|
||||
self.assertRaises(FileNotFoundError, cat, testfn + '-invalid')
|
||||
self.assertRaises(FileNotFoundError, bcat, testfn + '-invalid')
|
||||
self.assertEqual(cat(testfn + '-invalid', fallback="bar"), "bar")
|
||||
self.assertEqual(bcat(testfn + '-invalid', fallback="bar"), "bar")
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- Tests for wrap_numbers() function.
|
||||
# ===================================================================
|
||||
|
||||
|
||||
nt = collections.namedtuple('foo', 'a b c')
|
||||
|
||||
|
||||
class TestWrapNumbers(PsutilTestCase):
|
||||
|
||||
def setUp(self):
|
||||
wrap_numbers.cache_clear()
|
||||
|
||||
tearDown = setUp
|
||||
|
||||
def test_first_call(self):
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
|
||||
def test_input_hasnt_changed(self):
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
|
||||
def test_increase_but_no_wrap(self):
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
input = {'disk1': nt(10, 15, 20)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
input = {'disk1': nt(20, 25, 30)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
input = {'disk1': nt(20, 25, 30)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
|
||||
def test_wrap(self):
|
||||
# let's say 100 is the threshold
|
||||
input = {'disk1': nt(100, 100, 100)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
# first wrap restarts from 10
|
||||
input = {'disk1': nt(100, 100, 10)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(100, 100, 110)})
|
||||
# then it remains the same
|
||||
input = {'disk1': nt(100, 100, 10)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(100, 100, 110)})
|
||||
# then it goes up
|
||||
input = {'disk1': nt(100, 100, 90)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(100, 100, 190)})
|
||||
# then it wraps again
|
||||
input = {'disk1': nt(100, 100, 20)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(100, 100, 210)})
|
||||
# and remains the same
|
||||
input = {'disk1': nt(100, 100, 20)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(100, 100, 210)})
|
||||
# now wrap another num
|
||||
input = {'disk1': nt(50, 100, 20)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(150, 100, 210)})
|
||||
# and again
|
||||
input = {'disk1': nt(40, 100, 20)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(190, 100, 210)})
|
||||
# keep it the same
|
||||
input = {'disk1': nt(40, 100, 20)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(190, 100, 210)})
|
||||
|
||||
def test_changing_keys(self):
|
||||
# Emulate a case where the second call to disk_io()
|
||||
# (or whatever) provides a new disk, then the new disk
|
||||
# disappears on the third call.
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
input = {'disk1': nt(5, 5, 5),
|
||||
'disk2': nt(7, 7, 7)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
input = {'disk1': nt(8, 8, 8)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
|
||||
def test_changing_keys_w_wrap(self):
|
||||
input = {'disk1': nt(50, 50, 50),
|
||||
'disk2': nt(100, 100, 100)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
# disk 2 wraps
|
||||
input = {'disk1': nt(50, 50, 50),
|
||||
'disk2': nt(100, 100, 10)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(50, 50, 50),
|
||||
'disk2': nt(100, 100, 110)})
|
||||
# disk 2 disappears
|
||||
input = {'disk1': nt(50, 50, 50)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
|
||||
# then it appears again; the old wrap is supposed to be
|
||||
# gone.
|
||||
input = {'disk1': nt(50, 50, 50),
|
||||
'disk2': nt(100, 100, 100)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
# remains the same
|
||||
input = {'disk1': nt(50, 50, 50),
|
||||
'disk2': nt(100, 100, 100)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'), input)
|
||||
# and then wraps again
|
||||
input = {'disk1': nt(50, 50, 50),
|
||||
'disk2': nt(100, 100, 10)}
|
||||
self.assertEqual(wrap_numbers(input, 'disk_io'),
|
||||
{'disk1': nt(50, 50, 50),
|
||||
'disk2': nt(100, 100, 110)})
|
||||
|
||||
def test_real_data(self):
|
||||
d = {'nvme0n1': (300, 508, 640, 1571, 5970, 1987, 2049, 451751, 47048),
|
||||
'nvme0n1p1': (1171, 2, 5600256, 1024, 516, 0, 0, 0, 8),
|
||||
'nvme0n1p2': (54, 54, 2396160, 5165056, 4, 24, 30, 1207, 28),
|
||||
'nvme0n1p3': (2389, 4539, 5154, 150, 4828, 1844, 2019, 398, 348)}
|
||||
self.assertEqual(wrap_numbers(d, 'disk_io'), d)
|
||||
self.assertEqual(wrap_numbers(d, 'disk_io'), d)
|
||||
# decrease this ↓
|
||||
d = {'nvme0n1': (100, 508, 640, 1571, 5970, 1987, 2049, 451751, 47048),
|
||||
'nvme0n1p1': (1171, 2, 5600256, 1024, 516, 0, 0, 0, 8),
|
||||
'nvme0n1p2': (54, 54, 2396160, 5165056, 4, 24, 30, 1207, 28),
|
||||
'nvme0n1p3': (2389, 4539, 5154, 150, 4828, 1844, 2019, 398, 348)}
|
||||
out = wrap_numbers(d, 'disk_io')
|
||||
self.assertEqual(out['nvme0n1'][0], 400)
|
||||
|
||||
# --- cache tests
|
||||
|
||||
def test_cache_first_call(self):
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(cache[0], {'disk_io': input})
|
||||
self.assertEqual(cache[1], {'disk_io': {}})
|
||||
self.assertEqual(cache[2], {'disk_io': {}})
|
||||
|
||||
def test_cache_call_twice(self):
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
input = {'disk1': nt(10, 10, 10)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(cache[0], {'disk_io': input})
|
||||
self.assertEqual(
|
||||
cache[1],
|
||||
{'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 0}})
|
||||
self.assertEqual(cache[2], {'disk_io': {}})
|
||||
|
||||
def test_cache_wrap(self):
|
||||
# let's say 100 is the threshold
|
||||
input = {'disk1': nt(100, 100, 100)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
|
||||
# first wrap restarts from 10
|
||||
input = {'disk1': nt(100, 100, 10)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(cache[0], {'disk_io': input})
|
||||
self.assertEqual(
|
||||
cache[1],
|
||||
{'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 100}})
|
||||
self.assertEqual(cache[2], {'disk_io': {'disk1': set([('disk1', 2)])}})
|
||||
|
||||
def check_cache_info():
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(
|
||||
cache[1],
|
||||
{'disk_io': {('disk1', 0): 0, ('disk1', 1): 0,
|
||||
('disk1', 2): 100}})
|
||||
self.assertEqual(cache[2],
|
||||
{'disk_io': {'disk1': set([('disk1', 2)])}})
|
||||
|
||||
# then it remains the same
|
||||
input = {'disk1': nt(100, 100, 10)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(cache[0], {'disk_io': input})
|
||||
check_cache_info()
|
||||
|
||||
# then it goes up
|
||||
input = {'disk1': nt(100, 100, 90)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(cache[0], {'disk_io': input})
|
||||
check_cache_info()
|
||||
|
||||
# then it wraps again
|
||||
input = {'disk1': nt(100, 100, 20)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(cache[0], {'disk_io': input})
|
||||
self.assertEqual(
|
||||
cache[1],
|
||||
{'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 190}})
|
||||
self.assertEqual(cache[2], {'disk_io': {'disk1': set([('disk1', 2)])}})
|
||||
|
||||
def test_cache_changing_keys(self):
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
input = {'disk1': nt(5, 5, 5),
|
||||
'disk2': nt(7, 7, 7)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
cache = wrap_numbers.cache_info()
|
||||
self.assertEqual(cache[0], {'disk_io': input})
|
||||
self.assertEqual(
|
||||
cache[1],
|
||||
{'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 0}})
|
||||
self.assertEqual(cache[2], {'disk_io': {}})
|
||||
|
||||
def test_cache_clear(self):
|
||||
input = {'disk1': nt(5, 5, 5)}
|
||||
wrap_numbers(input, 'disk_io')
|
||||
wrap_numbers(input, 'disk_io')
|
||||
wrap_numbers.cache_clear('disk_io')
|
||||
self.assertEqual(wrap_numbers.cache_info(), ({}, {}, {}))
|
||||
wrap_numbers.cache_clear('disk_io')
|
||||
wrap_numbers.cache_clear('?!?')
|
||||
|
||||
@unittest.skipIf(not HAS_NET_IO_COUNTERS, 'not supported')
|
||||
def test_cache_clear_public_apis(self):
|
||||
if not psutil.disk_io_counters() or not psutil.net_io_counters():
|
||||
return self.skipTest("no disks or NICs available")
|
||||
psutil.disk_io_counters()
|
||||
psutil.net_io_counters()
|
||||
caches = wrap_numbers.cache_info()
|
||||
for cache in caches:
|
||||
self.assertIn('psutil.disk_io_counters', cache)
|
||||
self.assertIn('psutil.net_io_counters', cache)
|
||||
|
||||
psutil.disk_io_counters.cache_clear()
|
||||
caches = wrap_numbers.cache_info()
|
||||
for cache in caches:
|
||||
self.assertIn('psutil.net_io_counters', cache)
|
||||
self.assertNotIn('psutil.disk_io_counters', cache)
|
||||
|
||||
psutil.net_io_counters.cache_clear()
|
||||
caches = wrap_numbers.cache_info()
|
||||
self.assertEqual(caches, ({}, {}, {}))
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- Example script tests
|
||||
# ===================================================================
|
||||
|
||||
|
||||
@unittest.skipIf(not os.path.exists(SCRIPTS_DIR),
|
||||
"can't locate scripts directory")
|
||||
class TestScripts(PsutilTestCase):
|
||||
"""Tests for scripts in the "scripts" directory."""
|
||||
|
||||
@staticmethod
|
||||
def assert_stdout(exe, *args, **kwargs):
|
||||
kwargs.setdefault("env", PYTHON_EXE_ENV)
|
||||
exe = '%s' % os.path.join(SCRIPTS_DIR, exe)
|
||||
cmd = [PYTHON_EXE, exe]
|
||||
for arg in args:
|
||||
cmd.append(arg)
|
||||
try:
|
||||
out = sh(cmd, **kwargs).strip()
|
||||
except RuntimeError as err:
|
||||
if 'AccessDenied' in str(err):
|
||||
return str(err)
|
||||
else:
|
||||
raise
|
||||
assert out, out
|
||||
return out
|
||||
|
||||
@staticmethod
|
||||
def assert_syntax(exe):
|
||||
exe = os.path.join(SCRIPTS_DIR, exe)
|
||||
if PY3:
|
||||
f = open(exe, 'rt', encoding='utf8')
|
||||
else:
|
||||
f = open(exe, 'rt')
|
||||
with f:
|
||||
src = f.read()
|
||||
ast.parse(src)
|
||||
|
||||
def test_coverage(self):
|
||||
# make sure all example scripts have a test method defined
|
||||
meths = dir(self)
|
||||
for name in os.listdir(SCRIPTS_DIR):
|
||||
if name.endswith('.py'):
|
||||
if 'test_' + os.path.splitext(name)[0] not in meths:
|
||||
# self.assert_stdout(name)
|
||||
raise self.fail('no test defined for %r script'
|
||||
% os.path.join(SCRIPTS_DIR, name))
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
def test_executable(self):
|
||||
for root, dirs, files in os.walk(SCRIPTS_DIR):
|
||||
for file in files:
|
||||
if file.endswith('.py'):
|
||||
path = os.path.join(root, file)
|
||||
if not stat.S_IXUSR & os.stat(path)[stat.ST_MODE]:
|
||||
raise self.fail('%r is not executable' % path)
|
||||
|
||||
def test_disk_usage(self):
|
||||
self.assert_stdout('disk_usage.py')
|
||||
|
||||
def test_free(self):
|
||||
self.assert_stdout('free.py')
|
||||
|
||||
def test_meminfo(self):
|
||||
self.assert_stdout('meminfo.py')
|
||||
|
||||
def test_procinfo(self):
|
||||
self.assert_stdout('procinfo.py', str(os.getpid()))
|
||||
|
||||
@unittest.skipIf(CI_TESTING and not psutil.users(), "no users")
|
||||
def test_who(self):
|
||||
self.assert_stdout('who.py')
|
||||
|
||||
def test_ps(self):
|
||||
self.assert_stdout('ps.py')
|
||||
|
||||
def test_pstree(self):
|
||||
self.assert_stdout('pstree.py')
|
||||
|
||||
def test_netstat(self):
|
||||
self.assert_stdout('netstat.py')
|
||||
|
||||
def test_ifconfig(self):
|
||||
self.assert_stdout('ifconfig.py')
|
||||
|
||||
@unittest.skipIf(not HAS_MEMORY_MAPS, "not supported")
|
||||
def test_pmap(self):
|
||||
self.assert_stdout('pmap.py', str(os.getpid()))
|
||||
|
||||
def test_procsmem(self):
|
||||
if 'uss' not in psutil.Process().memory_full_info()._fields:
|
||||
raise self.skipTest("not supported")
|
||||
self.assert_stdout('procsmem.py')
|
||||
|
||||
def test_killall(self):
|
||||
self.assert_syntax('killall.py')
|
||||
|
||||
def test_nettop(self):
|
||||
self.assert_syntax('nettop.py')
|
||||
|
||||
def test_top(self):
|
||||
self.assert_syntax('top.py')
|
||||
|
||||
def test_iotop(self):
|
||||
self.assert_syntax('iotop.py')
|
||||
|
||||
def test_pidof(self):
|
||||
output = self.assert_stdout('pidof.py', psutil.Process().name())
|
||||
self.assertIn(str(os.getpid()), output)
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
def test_winservices(self):
|
||||
self.assert_stdout('winservices.py')
|
||||
|
||||
def test_cpu_distribution(self):
|
||||
self.assert_syntax('cpu_distribution.py')
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_TEMPERATURES, "not supported")
|
||||
def test_temperatures(self):
|
||||
if not psutil.sensors_temperatures():
|
||||
self.skipTest("no temperatures")
|
||||
self.assert_stdout('temperatures.py')
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_FANS, "not supported")
|
||||
def test_fans(self):
|
||||
if not psutil.sensors_fans():
|
||||
self.skipTest("no fans")
|
||||
self.assert_stdout('fans.py')
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_BATTERY, "not supported")
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_battery(self):
|
||||
self.assert_stdout('battery.py')
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_BATTERY, "not supported")
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_sensors(self):
|
||||
self.assert_stdout('sensors.py')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,204 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""macOS specific tests."""
|
||||
|
||||
import platform
|
||||
import re
|
||||
import time
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
from psutil import MACOS
|
||||
from psutil import POSIX
|
||||
from psutil.tests import HAS_BATTERY
|
||||
from psutil.tests import TOLERANCE_DISK_USAGE
|
||||
from psutil.tests import TOLERANCE_SYS_MEM
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import retry_on_failure
|
||||
from psutil.tests import sh
|
||||
from psutil.tests import spawn_testproc
|
||||
from psutil.tests import terminate
|
||||
|
||||
|
||||
if POSIX:
|
||||
from psutil._psutil_posix import getpagesize
|
||||
|
||||
|
||||
def sysctl(cmdline):
|
||||
"""Expects a sysctl command with an argument and parse the result
|
||||
returning only the value of interest.
|
||||
"""
|
||||
out = sh(cmdline)
|
||||
result = out.split()[1]
|
||||
try:
|
||||
return int(result)
|
||||
except ValueError:
|
||||
return result
|
||||
|
||||
|
||||
def vm_stat(field):
|
||||
"""Wrapper around 'vm_stat' cmdline utility."""
|
||||
out = sh('vm_stat')
|
||||
for line in out.split('\n'):
|
||||
if field in line:
|
||||
break
|
||||
else:
|
||||
raise ValueError("line not found")
|
||||
return int(re.search(r'\d+', line).group(0)) * getpagesize()
|
||||
|
||||
|
||||
@unittest.skipIf(not MACOS, "MACOS only")
|
||||
class TestProcess(PsutilTestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.pid = spawn_testproc().pid
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
terminate(cls.pid)
|
||||
|
||||
def test_process_create_time(self):
|
||||
output = sh("ps -o lstart -p %s" % self.pid)
|
||||
start_ps = output.replace('STARTED', '').strip()
|
||||
hhmmss = start_ps.split(' ')[-2]
|
||||
year = start_ps.split(' ')[-1]
|
||||
start_psutil = psutil.Process(self.pid).create_time()
|
||||
self.assertEqual(
|
||||
hhmmss,
|
||||
time.strftime("%H:%M:%S", time.localtime(start_psutil)))
|
||||
self.assertEqual(
|
||||
year,
|
||||
time.strftime("%Y", time.localtime(start_psutil)))
|
||||
|
||||
|
||||
@unittest.skipIf(not MACOS, "MACOS only")
|
||||
class TestSystemAPIs(PsutilTestCase):
|
||||
|
||||
# --- disk
|
||||
|
||||
@retry_on_failure()
|
||||
def test_disks(self):
|
||||
# test psutil.disk_usage() and psutil.disk_partitions()
|
||||
# against "df -a"
|
||||
def df(path):
|
||||
out = sh('df -k "%s"' % path).strip()
|
||||
lines = out.split('\n')
|
||||
lines.pop(0)
|
||||
line = lines.pop(0)
|
||||
dev, total, used, free = line.split()[:4]
|
||||
if dev == 'none':
|
||||
dev = ''
|
||||
total = int(total) * 1024
|
||||
used = int(used) * 1024
|
||||
free = int(free) * 1024
|
||||
return dev, total, used, free
|
||||
|
||||
for part in psutil.disk_partitions(all=False):
|
||||
usage = psutil.disk_usage(part.mountpoint)
|
||||
dev, total, used, free = df(part.mountpoint)
|
||||
self.assertEqual(part.device, dev)
|
||||
self.assertEqual(usage.total, total)
|
||||
self.assertAlmostEqual(usage.free, free,
|
||||
delta=TOLERANCE_DISK_USAGE)
|
||||
self.assertAlmostEqual(usage.used, used,
|
||||
delta=TOLERANCE_DISK_USAGE)
|
||||
|
||||
# --- cpu
|
||||
|
||||
def test_cpu_count_logical(self):
|
||||
num = sysctl("sysctl hw.logicalcpu")
|
||||
self.assertEqual(num, psutil.cpu_count(logical=True))
|
||||
|
||||
def test_cpu_count_cores(self):
|
||||
num = sysctl("sysctl hw.physicalcpu")
|
||||
self.assertEqual(num, psutil.cpu_count(logical=False))
|
||||
|
||||
# TODO: remove this once 1892 is fixed
|
||||
@unittest.skipIf(platform.machine() == 'arm64', "skipped due to #1892")
|
||||
def test_cpu_freq(self):
|
||||
freq = psutil.cpu_freq()
|
||||
self.assertEqual(
|
||||
freq.current * 1000 * 1000, sysctl("sysctl hw.cpufrequency"))
|
||||
self.assertEqual(
|
||||
freq.min * 1000 * 1000, sysctl("sysctl hw.cpufrequency_min"))
|
||||
self.assertEqual(
|
||||
freq.max * 1000 * 1000, sysctl("sysctl hw.cpufrequency_max"))
|
||||
|
||||
# --- virtual mem
|
||||
|
||||
def test_vmem_total(self):
|
||||
sysctl_hwphymem = sysctl('sysctl hw.memsize')
|
||||
self.assertEqual(sysctl_hwphymem, psutil.virtual_memory().total)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_free(self):
|
||||
vmstat_val = vm_stat("free")
|
||||
psutil_val = psutil.virtual_memory().free
|
||||
self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_active(self):
|
||||
vmstat_val = vm_stat("active")
|
||||
psutil_val = psutil.virtual_memory().active
|
||||
self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_inactive(self):
|
||||
vmstat_val = vm_stat("inactive")
|
||||
psutil_val = psutil.virtual_memory().inactive
|
||||
self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_vmem_wired(self):
|
||||
vmstat_val = vm_stat("wired")
|
||||
psutil_val = psutil.virtual_memory().wired
|
||||
self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
# --- swap mem
|
||||
|
||||
@retry_on_failure()
|
||||
def test_swapmem_sin(self):
|
||||
vmstat_val = vm_stat("Pageins")
|
||||
psutil_val = psutil.swap_memory().sin
|
||||
self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_swapmem_sout(self):
|
||||
vmstat_val = vm_stat("Pageout")
|
||||
psutil_val = psutil.swap_memory().sout
|
||||
self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
# --- network
|
||||
|
||||
def test_net_if_stats(self):
|
||||
for name, stats in psutil.net_if_stats().items():
|
||||
try:
|
||||
out = sh("ifconfig %s" % name)
|
||||
except RuntimeError:
|
||||
pass
|
||||
else:
|
||||
self.assertEqual(stats.isup, 'RUNNING' in out, msg=out)
|
||||
self.assertEqual(stats.mtu,
|
||||
int(re.findall(r'mtu (\d+)', out)[0]))
|
||||
|
||||
# --- sensors_battery
|
||||
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_sensors_battery(self):
|
||||
out = sh("pmset -g batt")
|
||||
percent = re.search(r"(\d+)%", out).group(1)
|
||||
drawing_from = re.search("Now drawing from '([^']+)'", out).group(1)
|
||||
power_plugged = drawing_from == "AC Power"
|
||||
psutil_result = psutil.sensors_battery()
|
||||
self.assertEqual(psutil_result.power_plugged, power_plugged)
|
||||
self.assertEqual(psutil_result.percent, int(percent))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,466 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# 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.
|
||||
|
||||
"""POSIX specific tests."""
|
||||
|
||||
import datetime
|
||||
import errno
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import time
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
from psutil import AIX
|
||||
from psutil import BSD
|
||||
from psutil import LINUX
|
||||
from psutil import MACOS
|
||||
from psutil import OPENBSD
|
||||
from psutil import POSIX
|
||||
from psutil import SUNOS
|
||||
from psutil.tests import HAS_NET_IO_COUNTERS
|
||||
from psutil.tests import PYTHON_EXE
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import mock
|
||||
from psutil.tests import retry_on_failure
|
||||
from psutil.tests import sh
|
||||
from psutil.tests import skip_on_access_denied
|
||||
from psutil.tests import spawn_testproc
|
||||
from psutil.tests import terminate
|
||||
from psutil.tests import which
|
||||
|
||||
|
||||
if POSIX:
|
||||
import mmap
|
||||
import resource
|
||||
|
||||
from psutil._psutil_posix import getpagesize
|
||||
|
||||
|
||||
def ps(fmt, pid=None):
|
||||
"""
|
||||
Wrapper for calling the ps command with a little bit of cross-platform
|
||||
support for a narrow range of features.
|
||||
"""
|
||||
|
||||
cmd = ['ps']
|
||||
|
||||
if LINUX:
|
||||
cmd.append('--no-headers')
|
||||
|
||||
if pid is not None:
|
||||
cmd.extend(['-p', str(pid)])
|
||||
else:
|
||||
if SUNOS or AIX:
|
||||
cmd.append('-A')
|
||||
else:
|
||||
cmd.append('ax')
|
||||
|
||||
if SUNOS:
|
||||
# XXX: set() has not get() method so this cannot work; not sure
|
||||
# what I meant in here.
|
||||
fmt_map = set(('command', 'comm', 'start', 'stime'))
|
||||
fmt = fmt_map.get(fmt, fmt)
|
||||
|
||||
cmd.extend(['-o', fmt])
|
||||
|
||||
output = sh(cmd)
|
||||
|
||||
if LINUX:
|
||||
output = output.splitlines()
|
||||
else:
|
||||
output = output.splitlines()[1:]
|
||||
|
||||
all_output = []
|
||||
for line in output:
|
||||
line = line.strip()
|
||||
|
||||
try:
|
||||
line = int(line)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
all_output.append(line)
|
||||
|
||||
if pid is None:
|
||||
return all_output
|
||||
else:
|
||||
return all_output[0]
|
||||
|
||||
# ps "-o" field names differ wildly between platforms.
|
||||
# "comm" means "only executable name" but is not available on BSD platforms.
|
||||
# "args" means "command with all its arguments", and is also not available
|
||||
# on BSD platforms.
|
||||
# "command" is like "args" on most platforms, but like "comm" on AIX,
|
||||
# and not available on SUNOS.
|
||||
# so for the executable name we can use "comm" on Solaris and split "command"
|
||||
# on other platforms.
|
||||
# to get the cmdline (with args) we have to use "args" on AIX and
|
||||
# Solaris, and can use "command" on all others.
|
||||
|
||||
|
||||
def ps_name(pid):
|
||||
field = "command"
|
||||
if SUNOS:
|
||||
field = "comm"
|
||||
return ps(field, pid).split()[0]
|
||||
|
||||
|
||||
def ps_args(pid):
|
||||
field = "command"
|
||||
if AIX or SUNOS:
|
||||
field = "args"
|
||||
out = ps(field, pid)
|
||||
# observed on BSD + Github CI: '/usr/local/bin/python3 -E -O (python3.9)'
|
||||
out = re.sub(r"\(python.*?\)$", "", out)
|
||||
return out.strip()
|
||||
|
||||
|
||||
def ps_rss(pid):
|
||||
field = "rss"
|
||||
if AIX:
|
||||
field = "rssize"
|
||||
return ps(field, pid)
|
||||
|
||||
|
||||
def ps_vsz(pid):
|
||||
field = "vsz"
|
||||
if AIX:
|
||||
field = "vsize"
|
||||
return ps(field, pid)
|
||||
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
class TestProcess(PsutilTestCase):
|
||||
"""Compare psutil results against 'ps' command line utility (mainly)."""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.pid = spawn_testproc([PYTHON_EXE, "-E", "-O"],
|
||||
stdin=subprocess.PIPE).pid
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
terminate(cls.pid)
|
||||
|
||||
def test_ppid(self):
|
||||
ppid_ps = ps('ppid', self.pid)
|
||||
ppid_psutil = psutil.Process(self.pid).ppid()
|
||||
self.assertEqual(ppid_ps, ppid_psutil)
|
||||
|
||||
def test_uid(self):
|
||||
uid_ps = ps('uid', self.pid)
|
||||
uid_psutil = psutil.Process(self.pid).uids().real
|
||||
self.assertEqual(uid_ps, uid_psutil)
|
||||
|
||||
def test_gid(self):
|
||||
gid_ps = ps('rgid', self.pid)
|
||||
gid_psutil = psutil.Process(self.pid).gids().real
|
||||
self.assertEqual(gid_ps, gid_psutil)
|
||||
|
||||
def test_username(self):
|
||||
username_ps = ps('user', self.pid)
|
||||
username_psutil = psutil.Process(self.pid).username()
|
||||
self.assertEqual(username_ps, username_psutil)
|
||||
|
||||
def test_username_no_resolution(self):
|
||||
# Emulate a case where the system can't resolve the uid to
|
||||
# a username in which case psutil is supposed to return
|
||||
# the stringified uid.
|
||||
p = psutil.Process()
|
||||
with mock.patch("psutil.pwd.getpwuid", side_effect=KeyError) as fun:
|
||||
self.assertEqual(p.username(), str(p.uids().real))
|
||||
assert fun.called
|
||||
|
||||
@skip_on_access_denied()
|
||||
@retry_on_failure()
|
||||
def test_rss_memory(self):
|
||||
# give python interpreter some time to properly initialize
|
||||
# so that the results are the same
|
||||
time.sleep(0.1)
|
||||
rss_ps = ps_rss(self.pid)
|
||||
rss_psutil = psutil.Process(self.pid).memory_info()[0] / 1024
|
||||
self.assertEqual(rss_ps, rss_psutil)
|
||||
|
||||
@skip_on_access_denied()
|
||||
@retry_on_failure()
|
||||
def test_vsz_memory(self):
|
||||
# give python interpreter some time to properly initialize
|
||||
# so that the results are the same
|
||||
time.sleep(0.1)
|
||||
vsz_ps = ps_vsz(self.pid)
|
||||
vsz_psutil = psutil.Process(self.pid).memory_info()[1] / 1024
|
||||
self.assertEqual(vsz_ps, vsz_psutil)
|
||||
|
||||
def test_name(self):
|
||||
name_ps = ps_name(self.pid)
|
||||
# remove path if there is any, from the command
|
||||
name_ps = os.path.basename(name_ps).lower()
|
||||
name_psutil = psutil.Process(self.pid).name().lower()
|
||||
# ...because of how we calculate PYTHON_EXE; on MACOS this may
|
||||
# be "pythonX.Y".
|
||||
name_ps = re.sub(r"\d.\d", "", name_ps)
|
||||
name_psutil = re.sub(r"\d.\d", "", name_psutil)
|
||||
# ...may also be "python.X"
|
||||
name_ps = re.sub(r"\d", "", name_ps)
|
||||
name_psutil = re.sub(r"\d", "", name_psutil)
|
||||
self.assertEqual(name_ps, name_psutil)
|
||||
|
||||
def test_name_long(self):
|
||||
# On UNIX the kernel truncates the name to the first 15
|
||||
# characters. In such a case psutil tries to determine the
|
||||
# full name from the cmdline.
|
||||
name = "long-program-name"
|
||||
cmdline = ["long-program-name-extended", "foo", "bar"]
|
||||
with mock.patch("psutil._psplatform.Process.name",
|
||||
return_value=name):
|
||||
with mock.patch("psutil._psplatform.Process.cmdline",
|
||||
return_value=cmdline):
|
||||
p = psutil.Process()
|
||||
self.assertEqual(p.name(), "long-program-name-extended")
|
||||
|
||||
def test_name_long_cmdline_ad_exc(self):
|
||||
# Same as above but emulates a case where cmdline() raises
|
||||
# AccessDenied in which case psutil is supposed to return
|
||||
# the truncated name instead of crashing.
|
||||
name = "long-program-name"
|
||||
with mock.patch("psutil._psplatform.Process.name",
|
||||
return_value=name):
|
||||
with mock.patch("psutil._psplatform.Process.cmdline",
|
||||
side_effect=psutil.AccessDenied(0, "")):
|
||||
p = psutil.Process()
|
||||
self.assertEqual(p.name(), "long-program-name")
|
||||
|
||||
def test_name_long_cmdline_nsp_exc(self):
|
||||
# Same as above but emulates a case where cmdline() raises NSP
|
||||
# which is supposed to propagate.
|
||||
name = "long-program-name"
|
||||
with mock.patch("psutil._psplatform.Process.name",
|
||||
return_value=name):
|
||||
with mock.patch("psutil._psplatform.Process.cmdline",
|
||||
side_effect=psutil.NoSuchProcess(0, "")):
|
||||
p = psutil.Process()
|
||||
self.assertRaises(psutil.NoSuchProcess, p.name)
|
||||
|
||||
@unittest.skipIf(MACOS or BSD, 'ps -o start not available')
|
||||
def test_create_time(self):
|
||||
time_ps = ps('start', self.pid)
|
||||
time_psutil = psutil.Process(self.pid).create_time()
|
||||
time_psutil_tstamp = datetime.datetime.fromtimestamp(
|
||||
time_psutil).strftime("%H:%M:%S")
|
||||
# sometimes ps shows the time rounded up instead of down, so we check
|
||||
# for both possible values
|
||||
round_time_psutil = round(time_psutil)
|
||||
round_time_psutil_tstamp = datetime.datetime.fromtimestamp(
|
||||
round_time_psutil).strftime("%H:%M:%S")
|
||||
self.assertIn(time_ps, [time_psutil_tstamp, round_time_psutil_tstamp])
|
||||
|
||||
def test_exe(self):
|
||||
ps_pathname = ps_name(self.pid)
|
||||
psutil_pathname = psutil.Process(self.pid).exe()
|
||||
try:
|
||||
self.assertEqual(ps_pathname, psutil_pathname)
|
||||
except AssertionError:
|
||||
# certain platforms such as BSD are more accurate returning:
|
||||
# "/usr/local/bin/python2.7"
|
||||
# ...instead of:
|
||||
# "/usr/local/bin/python"
|
||||
# We do not want to consider this difference in accuracy
|
||||
# an error.
|
||||
adjusted_ps_pathname = ps_pathname[:len(ps_pathname)]
|
||||
self.assertEqual(ps_pathname, adjusted_ps_pathname)
|
||||
|
||||
# On macOS the official python installer exposes a python wrapper that
|
||||
# executes a python executable hidden inside an application bundle inside
|
||||
# the Python framework.
|
||||
# There's a race condition between the ps call & the psutil call below
|
||||
# depending on the completion of the execve call so let's retry on failure
|
||||
@retry_on_failure()
|
||||
def test_cmdline(self):
|
||||
ps_cmdline = ps_args(self.pid)
|
||||
psutil_cmdline = " ".join(psutil.Process(self.pid).cmdline())
|
||||
self.assertEqual(ps_cmdline, psutil_cmdline)
|
||||
|
||||
# On SUNOS "ps" reads niceness /proc/pid/psinfo which returns an
|
||||
# incorrect value (20); the real deal is getpriority(2) which
|
||||
# returns 0; psutil relies on it, see:
|
||||
# https://github.com/giampaolo/psutil/issues/1082
|
||||
# AIX has the same issue
|
||||
@unittest.skipIf(SUNOS, "not reliable on SUNOS")
|
||||
@unittest.skipIf(AIX, "not reliable on AIX")
|
||||
def test_nice(self):
|
||||
ps_nice = ps('nice', self.pid)
|
||||
psutil_nice = psutil.Process().nice()
|
||||
self.assertEqual(ps_nice, psutil_nice)
|
||||
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
class TestSystemAPIs(PsutilTestCase):
|
||||
"""Test some system APIs."""
|
||||
|
||||
@retry_on_failure()
|
||||
def test_pids(self):
|
||||
# Note: this test might fail if the OS is starting/killing
|
||||
# other processes in the meantime
|
||||
pids_ps = sorted(ps("pid"))
|
||||
pids_psutil = psutil.pids()
|
||||
|
||||
# on MACOS and OPENBSD ps doesn't show pid 0
|
||||
if MACOS or OPENBSD and 0 not in pids_ps:
|
||||
pids_ps.insert(0, 0)
|
||||
|
||||
# There will often be one more process in pids_ps for ps itself
|
||||
if len(pids_ps) - len(pids_psutil) > 1:
|
||||
difference = [x for x in pids_psutil if x not in pids_ps] + \
|
||||
[x for x in pids_ps if x not in pids_psutil]
|
||||
raise self.fail("difference: " + str(difference))
|
||||
|
||||
# for some reason ifconfig -a does not report all interfaces
|
||||
# returned by psutil
|
||||
@unittest.skipIf(SUNOS, "unreliable on SUNOS")
|
||||
@unittest.skipIf(not which('ifconfig'), "no ifconfig cmd")
|
||||
@unittest.skipIf(not HAS_NET_IO_COUNTERS, "not supported")
|
||||
def test_nic_names(self):
|
||||
output = sh("ifconfig -a")
|
||||
for nic in psutil.net_io_counters(pernic=True).keys():
|
||||
for line in output.split():
|
||||
if line.startswith(nic):
|
||||
break
|
||||
else:
|
||||
raise self.fail(
|
||||
"couldn't find %s nic in 'ifconfig -a' output\n%s" % (
|
||||
nic, output))
|
||||
|
||||
# @unittest.skipIf(CI_TESTING and not psutil.users(), "unreliable on CI")
|
||||
@retry_on_failure()
|
||||
def test_users(self):
|
||||
out = sh("who -u")
|
||||
if not out.strip():
|
||||
raise self.skipTest("no users on this system")
|
||||
lines = out.split('\n')
|
||||
users = [x.split()[0] for x in lines]
|
||||
terminals = [x.split()[1] for x in lines]
|
||||
self.assertEqual(len(users), len(psutil.users()))
|
||||
with self.subTest(psutil=psutil.users(), who=out):
|
||||
for idx, u in enumerate(psutil.users()):
|
||||
self.assertEqual(u.name, users[idx])
|
||||
self.assertEqual(u.terminal, terminals[idx])
|
||||
if u.pid is not None: # None on OpenBSD
|
||||
psutil.Process(u.pid)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_users_started(self):
|
||||
out = sh("who -u")
|
||||
if not out.strip():
|
||||
raise self.skipTest("no users on this system")
|
||||
# '2023-04-11 09:31' (Linux)
|
||||
started = re.findall(r"\d\d\d\d-\d\d-\d\d \d\d:\d\d", out)
|
||||
if started:
|
||||
tstamp = "%Y-%m-%d %H:%M"
|
||||
else:
|
||||
# 'Apr 10 22:27' (macOS)
|
||||
started = re.findall(r"[A-Z][a-z][a-z] \d\d \d\d:\d\d", out)
|
||||
if started:
|
||||
tstamp = "%b %d %H:%M"
|
||||
else:
|
||||
raise ValueError(
|
||||
"cannot interpret tstamp in who output\n%s" % (out))
|
||||
with self.subTest(psutil=psutil.users(), who=out):
|
||||
for idx, u in enumerate(psutil.users()):
|
||||
psutil_value = datetime.datetime.fromtimestamp(
|
||||
u.started).strftime(tstamp)
|
||||
self.assertEqual(psutil_value, started[idx])
|
||||
|
||||
def test_pid_exists_let_raise(self):
|
||||
# According to "man 2 kill" possible error values for kill
|
||||
# are (EINVAL, EPERM, ESRCH). Test that any other errno
|
||||
# results in an exception.
|
||||
with mock.patch("psutil._psposix.os.kill",
|
||||
side_effect=OSError(errno.EBADF, "")) as m:
|
||||
self.assertRaises(OSError, psutil._psposix.pid_exists, os.getpid())
|
||||
assert m.called
|
||||
|
||||
def test_os_waitpid_let_raise(self):
|
||||
# os.waitpid() is supposed to catch EINTR and ECHILD only.
|
||||
# Test that any other errno results in an exception.
|
||||
with mock.patch("psutil._psposix.os.waitpid",
|
||||
side_effect=OSError(errno.EBADF, "")) as m:
|
||||
self.assertRaises(OSError, psutil._psposix.wait_pid, os.getpid())
|
||||
assert m.called
|
||||
|
||||
def test_os_waitpid_eintr(self):
|
||||
# os.waitpid() is supposed to "retry" on EINTR.
|
||||
with mock.patch("psutil._psposix.os.waitpid",
|
||||
side_effect=OSError(errno.EINTR, "")) as m:
|
||||
self.assertRaises(
|
||||
psutil._psposix.TimeoutExpired,
|
||||
psutil._psposix.wait_pid, os.getpid(), timeout=0.01)
|
||||
assert m.called
|
||||
|
||||
def test_os_waitpid_bad_ret_status(self):
|
||||
# Simulate os.waitpid() returning a bad status.
|
||||
with mock.patch("psutil._psposix.os.waitpid",
|
||||
return_value=(1, -1)) as m:
|
||||
self.assertRaises(ValueError,
|
||||
psutil._psposix.wait_pid, os.getpid())
|
||||
assert m.called
|
||||
|
||||
# AIX can return '-' in df output instead of numbers, e.g. for /proc
|
||||
@unittest.skipIf(AIX, "unreliable on AIX")
|
||||
@retry_on_failure()
|
||||
def test_disk_usage(self):
|
||||
def df(device):
|
||||
try:
|
||||
out = sh("df -k %s" % device).strip()
|
||||
except RuntimeError as err:
|
||||
if "device busy" in str(err).lower():
|
||||
raise self.skipTest("df returned EBUSY")
|
||||
raise
|
||||
line = out.split('\n')[1]
|
||||
fields = line.split()
|
||||
total = int(fields[1]) * 1024
|
||||
used = int(fields[2]) * 1024
|
||||
free = int(fields[3]) * 1024
|
||||
percent = float(fields[4].replace('%', ''))
|
||||
return (total, used, free, percent)
|
||||
|
||||
tolerance = 4 * 1024 * 1024 # 4MB
|
||||
for part in psutil.disk_partitions(all=False):
|
||||
usage = psutil.disk_usage(part.mountpoint)
|
||||
try:
|
||||
total, used, free, percent = df(part.device)
|
||||
except RuntimeError as err:
|
||||
# see:
|
||||
# https://travis-ci.org/giampaolo/psutil/jobs/138338464
|
||||
# https://travis-ci.org/giampaolo/psutil/jobs/138343361
|
||||
err = str(err).lower()
|
||||
if "no such file or directory" in err or \
|
||||
"raw devices not supported" in err or \
|
||||
"permission denied" in err:
|
||||
continue
|
||||
raise
|
||||
else:
|
||||
self.assertAlmostEqual(usage.total, total, delta=tolerance)
|
||||
self.assertAlmostEqual(usage.used, used, delta=tolerance)
|
||||
self.assertAlmostEqual(usage.free, free, delta=tolerance)
|
||||
self.assertAlmostEqual(usage.percent, percent, delta=1)
|
||||
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
class TestMisc(PsutilTestCase):
|
||||
|
||||
def test_getpagesize(self):
|
||||
pagesize = getpagesize()
|
||||
self.assertGreater(pagesize, 0)
|
||||
self.assertEqual(pagesize, resource.getpagesize())
|
||||
self.assertEqual(pagesize, mmap.PAGESIZE)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,46 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""Sun OS specific tests."""
|
||||
|
||||
import os
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
from psutil import SUNOS
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import sh
|
||||
|
||||
|
||||
@unittest.skipIf(not SUNOS, "SUNOS only")
|
||||
class SunOSSpecificTestCase(PsutilTestCase):
|
||||
|
||||
def test_swap_memory(self):
|
||||
out = sh('env PATH=/usr/sbin:/sbin:%s swap -l' % os.environ['PATH'])
|
||||
lines = out.strip().split('\n')[1:]
|
||||
if not lines:
|
||||
raise ValueError('no swap device(s) configured')
|
||||
total = free = 0
|
||||
for line in lines:
|
||||
line = line.split()
|
||||
t, f = line[-2:]
|
||||
total += int(int(t) * 512)
|
||||
free += int(int(f) * 512)
|
||||
used = total - free
|
||||
|
||||
psutil_swap = psutil.swap_memory()
|
||||
self.assertEqual(psutil_swap.total, total)
|
||||
self.assertEqual(psutil_swap.used, used)
|
||||
self.assertEqual(psutil_swap.free, free)
|
||||
|
||||
def test_cpu_count(self):
|
||||
out = sh("/usr/sbin/psrinfo")
|
||||
self.assertEqual(psutil.cpu_count(), len(out.split('\n')))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,892 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# 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.
|
||||
|
||||
"""Tests for system APIS."""
|
||||
|
||||
import contextlib
|
||||
import datetime
|
||||
import errno
|
||||
import os
|
||||
import platform
|
||||
import pprint
|
||||
import shutil
|
||||
import signal
|
||||
import socket
|
||||
import sys
|
||||
import time
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
from psutil import AIX
|
||||
from psutil import BSD
|
||||
from psutil import FREEBSD
|
||||
from psutil import LINUX
|
||||
from psutil import MACOS
|
||||
from psutil import NETBSD
|
||||
from psutil import OPENBSD
|
||||
from psutil import POSIX
|
||||
from psutil import SUNOS
|
||||
from psutil import WINDOWS
|
||||
from psutil._compat import FileNotFoundError
|
||||
from psutil._compat import long
|
||||
from psutil.tests import ASCII_FS
|
||||
from psutil.tests import CI_TESTING
|
||||
from psutil.tests import DEVNULL
|
||||
from psutil.tests import GITHUB_ACTIONS
|
||||
from psutil.tests import GLOBAL_TIMEOUT
|
||||
from psutil.tests import HAS_BATTERY
|
||||
from psutil.tests import HAS_CPU_FREQ
|
||||
from psutil.tests import HAS_GETLOADAVG
|
||||
from psutil.tests import HAS_NET_IO_COUNTERS
|
||||
from psutil.tests import HAS_SENSORS_BATTERY
|
||||
from psutil.tests import HAS_SENSORS_FANS
|
||||
from psutil.tests import HAS_SENSORS_TEMPERATURES
|
||||
from psutil.tests import IS_64BIT
|
||||
from psutil.tests import MACOS_12PLUS
|
||||
from psutil.tests import PYPY
|
||||
from psutil.tests import UNICODE_SUFFIX
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import check_net_address
|
||||
from psutil.tests import enum
|
||||
from psutil.tests import mock
|
||||
from psutil.tests import retry_on_failure
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- System-related API tests
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestProcessAPIs(PsutilTestCase):
|
||||
|
||||
def test_process_iter(self):
|
||||
self.assertIn(os.getpid(), [x.pid for x in psutil.process_iter()])
|
||||
sproc = self.spawn_testproc()
|
||||
self.assertIn(sproc.pid, [x.pid for x in psutil.process_iter()])
|
||||
p = psutil.Process(sproc.pid)
|
||||
p.kill()
|
||||
p.wait()
|
||||
self.assertNotIn(sproc.pid, [x.pid for x in psutil.process_iter()])
|
||||
|
||||
with mock.patch('psutil.Process',
|
||||
side_effect=psutil.NoSuchProcess(os.getpid())):
|
||||
self.assertEqual(list(psutil.process_iter()), [])
|
||||
with mock.patch('psutil.Process',
|
||||
side_effect=psutil.AccessDenied(os.getpid())):
|
||||
with self.assertRaises(psutil.AccessDenied):
|
||||
list(psutil.process_iter())
|
||||
|
||||
def test_prcess_iter_w_attrs(self):
|
||||
for p in psutil.process_iter(attrs=['pid']):
|
||||
self.assertEqual(list(p.info.keys()), ['pid'])
|
||||
with self.assertRaises(ValueError):
|
||||
list(psutil.process_iter(attrs=['foo']))
|
||||
with mock.patch("psutil._psplatform.Process.cpu_times",
|
||||
side_effect=psutil.AccessDenied(0, "")) as m:
|
||||
for p in psutil.process_iter(attrs=["pid", "cpu_times"]):
|
||||
self.assertIsNone(p.info['cpu_times'])
|
||||
self.assertGreaterEqual(p.info['pid'], 0)
|
||||
assert m.called
|
||||
with mock.patch("psutil._psplatform.Process.cpu_times",
|
||||
side_effect=psutil.AccessDenied(0, "")) as m:
|
||||
flag = object()
|
||||
for p in psutil.process_iter(
|
||||
attrs=["pid", "cpu_times"], ad_value=flag):
|
||||
self.assertIs(p.info['cpu_times'], flag)
|
||||
self.assertGreaterEqual(p.info['pid'], 0)
|
||||
assert m.called
|
||||
|
||||
@unittest.skipIf(PYPY and WINDOWS,
|
||||
"spawn_testproc() unreliable on PYPY + WINDOWS")
|
||||
def test_wait_procs(self):
|
||||
def callback(p):
|
||||
pids.append(p.pid)
|
||||
|
||||
pids = []
|
||||
sproc1 = self.spawn_testproc()
|
||||
sproc2 = self.spawn_testproc()
|
||||
sproc3 = self.spawn_testproc()
|
||||
procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
|
||||
self.assertRaises(ValueError, psutil.wait_procs, procs, timeout=-1)
|
||||
self.assertRaises(TypeError, psutil.wait_procs, procs, callback=1)
|
||||
t = time.time()
|
||||
gone, alive = psutil.wait_procs(procs, timeout=0.01, callback=callback)
|
||||
|
||||
self.assertLess(time.time() - t, 0.5)
|
||||
self.assertEqual(gone, [])
|
||||
self.assertEqual(len(alive), 3)
|
||||
self.assertEqual(pids, [])
|
||||
for p in alive:
|
||||
self.assertFalse(hasattr(p, 'returncode'))
|
||||
|
||||
@retry_on_failure(30)
|
||||
def test_1(procs, callback):
|
||||
gone, alive = psutil.wait_procs(procs, timeout=0.03,
|
||||
callback=callback)
|
||||
self.assertEqual(len(gone), 1)
|
||||
self.assertEqual(len(alive), 2)
|
||||
return gone, alive
|
||||
|
||||
sproc3.terminate()
|
||||
gone, alive = test_1(procs, callback)
|
||||
self.assertIn(sproc3.pid, [x.pid for x in gone])
|
||||
if POSIX:
|
||||
self.assertEqual(gone.pop().returncode, -signal.SIGTERM)
|
||||
else:
|
||||
self.assertEqual(gone.pop().returncode, 1)
|
||||
self.assertEqual(pids, [sproc3.pid])
|
||||
for p in alive:
|
||||
self.assertFalse(hasattr(p, 'returncode'))
|
||||
|
||||
@retry_on_failure(30)
|
||||
def test_2(procs, callback):
|
||||
gone, alive = psutil.wait_procs(procs, timeout=0.03,
|
||||
callback=callback)
|
||||
self.assertEqual(len(gone), 3)
|
||||
self.assertEqual(len(alive), 0)
|
||||
return gone, alive
|
||||
|
||||
sproc1.terminate()
|
||||
sproc2.terminate()
|
||||
gone, alive = test_2(procs, callback)
|
||||
self.assertEqual(set(pids), set([sproc1.pid, sproc2.pid, sproc3.pid]))
|
||||
for p in gone:
|
||||
self.assertTrue(hasattr(p, 'returncode'))
|
||||
|
||||
@unittest.skipIf(PYPY and WINDOWS,
|
||||
"spawn_testproc() unreliable on PYPY + WINDOWS")
|
||||
def test_wait_procs_no_timeout(self):
|
||||
sproc1 = self.spawn_testproc()
|
||||
sproc2 = self.spawn_testproc()
|
||||
sproc3 = self.spawn_testproc()
|
||||
procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
|
||||
for p in procs:
|
||||
p.terminate()
|
||||
psutil.wait_procs(procs)
|
||||
|
||||
def test_pid_exists(self):
|
||||
sproc = self.spawn_testproc()
|
||||
self.assertTrue(psutil.pid_exists(sproc.pid))
|
||||
p = psutil.Process(sproc.pid)
|
||||
p.kill()
|
||||
p.wait()
|
||||
self.assertFalse(psutil.pid_exists(sproc.pid))
|
||||
self.assertFalse(psutil.pid_exists(-1))
|
||||
self.assertEqual(psutil.pid_exists(0), 0 in psutil.pids())
|
||||
|
||||
def test_pid_exists_2(self):
|
||||
pids = psutil.pids()
|
||||
for pid in pids:
|
||||
try:
|
||||
assert psutil.pid_exists(pid)
|
||||
except AssertionError:
|
||||
# in case the process disappeared in meantime fail only
|
||||
# if it is no longer in psutil.pids()
|
||||
time.sleep(.1)
|
||||
self.assertNotIn(pid, psutil.pids())
|
||||
pids = range(max(pids) + 15000, max(pids) + 16000)
|
||||
for pid in pids:
|
||||
self.assertFalse(psutil.pid_exists(pid), msg=pid)
|
||||
|
||||
|
||||
class TestMiscAPIs(PsutilTestCase):
|
||||
|
||||
def test_boot_time(self):
|
||||
bt = psutil.boot_time()
|
||||
self.assertIsInstance(bt, float)
|
||||
self.assertGreater(bt, 0)
|
||||
self.assertLess(bt, time.time())
|
||||
|
||||
@unittest.skipIf(CI_TESTING and not psutil.users(), "unreliable on CI")
|
||||
def test_users(self):
|
||||
users = psutil.users()
|
||||
self.assertNotEqual(users, [])
|
||||
for user in users:
|
||||
assert user.name, user
|
||||
self.assertIsInstance(user.name, str)
|
||||
self.assertIsInstance(user.terminal, (str, type(None)))
|
||||
if user.host is not None:
|
||||
self.assertIsInstance(user.host, (str, type(None)))
|
||||
user.terminal
|
||||
user.host
|
||||
assert user.started > 0.0, user
|
||||
datetime.datetime.fromtimestamp(user.started)
|
||||
if WINDOWS or OPENBSD:
|
||||
self.assertIsNone(user.pid)
|
||||
else:
|
||||
psutil.Process(user.pid)
|
||||
|
||||
def test_test(self):
|
||||
# test for psutil.test() function
|
||||
stdout = sys.stdout
|
||||
sys.stdout = DEVNULL
|
||||
try:
|
||||
psutil.test()
|
||||
finally:
|
||||
sys.stdout = stdout
|
||||
|
||||
def test_os_constants(self):
|
||||
names = ["POSIX", "WINDOWS", "LINUX", "MACOS", "FREEBSD", "OPENBSD",
|
||||
"NETBSD", "BSD", "SUNOS"]
|
||||
for name in names:
|
||||
self.assertIsInstance(getattr(psutil, name), bool, msg=name)
|
||||
|
||||
if os.name == 'posix':
|
||||
assert psutil.POSIX
|
||||
assert not psutil.WINDOWS
|
||||
names.remove("POSIX")
|
||||
if "linux" in sys.platform.lower():
|
||||
assert psutil.LINUX
|
||||
names.remove("LINUX")
|
||||
elif "bsd" in sys.platform.lower():
|
||||
assert psutil.BSD
|
||||
self.assertEqual([psutil.FREEBSD, psutil.OPENBSD,
|
||||
psutil.NETBSD].count(True), 1)
|
||||
names.remove("BSD")
|
||||
names.remove("FREEBSD")
|
||||
names.remove("OPENBSD")
|
||||
names.remove("NETBSD")
|
||||
elif "sunos" in sys.platform.lower() or \
|
||||
"solaris" in sys.platform.lower():
|
||||
assert psutil.SUNOS
|
||||
names.remove("SUNOS")
|
||||
elif "darwin" in sys.platform.lower():
|
||||
assert psutil.MACOS
|
||||
names.remove("MACOS")
|
||||
else:
|
||||
assert psutil.WINDOWS
|
||||
assert not psutil.POSIX
|
||||
names.remove("WINDOWS")
|
||||
|
||||
# assert all other constants are set to False
|
||||
for name in names:
|
||||
self.assertIs(getattr(psutil, name), False, msg=name)
|
||||
|
||||
|
||||
class TestMemoryAPIs(PsutilTestCase):
|
||||
|
||||
def test_virtual_memory(self):
|
||||
mem = psutil.virtual_memory()
|
||||
assert mem.total > 0, mem
|
||||
assert mem.available > 0, mem
|
||||
assert 0 <= mem.percent <= 100, mem
|
||||
assert mem.used > 0, mem
|
||||
assert mem.free >= 0, mem
|
||||
for name in mem._fields:
|
||||
value = getattr(mem, name)
|
||||
if name != 'percent':
|
||||
self.assertIsInstance(value, (int, long))
|
||||
if name != 'total':
|
||||
if not value >= 0:
|
||||
raise self.fail("%r < 0 (%s)" % (name, value))
|
||||
if value > mem.total:
|
||||
raise self.fail("%r > total (total=%s, %s=%s)"
|
||||
% (name, mem.total, name, value))
|
||||
|
||||
def test_swap_memory(self):
|
||||
mem = psutil.swap_memory()
|
||||
self.assertEqual(
|
||||
mem._fields, ('total', 'used', 'free', 'percent', 'sin', 'sout'))
|
||||
|
||||
assert mem.total >= 0, mem
|
||||
assert mem.used >= 0, mem
|
||||
if mem.total > 0:
|
||||
# likely a system with no swap partition
|
||||
assert mem.free > 0, mem
|
||||
else:
|
||||
assert mem.free == 0, mem
|
||||
assert 0 <= mem.percent <= 100, mem
|
||||
assert mem.sin >= 0, mem
|
||||
assert mem.sout >= 0, mem
|
||||
|
||||
|
||||
class TestCpuAPIs(PsutilTestCase):
|
||||
|
||||
def test_cpu_count_logical(self):
|
||||
logical = psutil.cpu_count()
|
||||
self.assertIsNotNone(logical)
|
||||
self.assertEqual(logical, len(psutil.cpu_times(percpu=True)))
|
||||
self.assertGreaterEqual(logical, 1)
|
||||
#
|
||||
if os.path.exists("/proc/cpuinfo"):
|
||||
with open("/proc/cpuinfo") as fd:
|
||||
cpuinfo_data = fd.read()
|
||||
if "physical id" not in cpuinfo_data:
|
||||
raise unittest.SkipTest("cpuinfo doesn't include physical id")
|
||||
|
||||
def test_cpu_count_cores(self):
|
||||
logical = psutil.cpu_count()
|
||||
cores = psutil.cpu_count(logical=False)
|
||||
if cores is None:
|
||||
raise self.skipTest("cpu_count_cores() is None")
|
||||
if WINDOWS and sys.getwindowsversion()[:2] <= (6, 1): # <= Vista
|
||||
self.assertIsNone(cores)
|
||||
else:
|
||||
self.assertGreaterEqual(cores, 1)
|
||||
self.assertGreaterEqual(logical, cores)
|
||||
|
||||
def test_cpu_count_none(self):
|
||||
# https://github.com/giampaolo/psutil/issues/1085
|
||||
for val in (-1, 0, None):
|
||||
with mock.patch('psutil._psplatform.cpu_count_logical',
|
||||
return_value=val) as m:
|
||||
self.assertIsNone(psutil.cpu_count())
|
||||
assert m.called
|
||||
with mock.patch('psutil._psplatform.cpu_count_cores',
|
||||
return_value=val) as m:
|
||||
self.assertIsNone(psutil.cpu_count(logical=False))
|
||||
assert m.called
|
||||
|
||||
def test_cpu_times(self):
|
||||
# Check type, value >= 0, str().
|
||||
total = 0
|
||||
times = psutil.cpu_times()
|
||||
sum(times)
|
||||
for cp_time in times:
|
||||
self.assertIsInstance(cp_time, float)
|
||||
self.assertGreaterEqual(cp_time, 0.0)
|
||||
total += cp_time
|
||||
self.assertEqual(total, sum(times))
|
||||
str(times)
|
||||
# CPU times are always supposed to increase over time
|
||||
# or at least remain the same and that's because time
|
||||
# cannot go backwards.
|
||||
# Surprisingly sometimes this might not be the case (at
|
||||
# least on Windows and Linux), see:
|
||||
# https://github.com/giampaolo/psutil/issues/392
|
||||
# https://github.com/giampaolo/psutil/issues/645
|
||||
# if not WINDOWS:
|
||||
# last = psutil.cpu_times()
|
||||
# for x in range(100):
|
||||
# new = psutil.cpu_times()
|
||||
# for field in new._fields:
|
||||
# new_t = getattr(new, field)
|
||||
# last_t = getattr(last, field)
|
||||
# self.assertGreaterEqual(new_t, last_t,
|
||||
# msg="%s %s" % (new_t, last_t))
|
||||
# last = new
|
||||
|
||||
def test_cpu_times_time_increases(self):
|
||||
# Make sure time increases between calls.
|
||||
t1 = sum(psutil.cpu_times())
|
||||
stop_at = time.time() + GLOBAL_TIMEOUT
|
||||
while time.time() < stop_at:
|
||||
t2 = sum(psutil.cpu_times())
|
||||
if t2 > t1:
|
||||
return
|
||||
raise self.fail("time remained the same")
|
||||
|
||||
def test_per_cpu_times(self):
|
||||
# Check type, value >= 0, str().
|
||||
for times in psutil.cpu_times(percpu=True):
|
||||
total = 0
|
||||
sum(times)
|
||||
for cp_time in times:
|
||||
self.assertIsInstance(cp_time, float)
|
||||
self.assertGreaterEqual(cp_time, 0.0)
|
||||
total += cp_time
|
||||
self.assertEqual(total, sum(times))
|
||||
str(times)
|
||||
self.assertEqual(len(psutil.cpu_times(percpu=True)[0]),
|
||||
len(psutil.cpu_times(percpu=False)))
|
||||
|
||||
# Note: in theory CPU times are always supposed to increase over
|
||||
# time or remain the same but never go backwards. In practice
|
||||
# sometimes this is not the case.
|
||||
# This issue seemd to be afflict Windows:
|
||||
# https://github.com/giampaolo/psutil/issues/392
|
||||
# ...but it turns out also Linux (rarely) behaves the same.
|
||||
# last = psutil.cpu_times(percpu=True)
|
||||
# for x in range(100):
|
||||
# new = psutil.cpu_times(percpu=True)
|
||||
# for index in range(len(new)):
|
||||
# newcpu = new[index]
|
||||
# lastcpu = last[index]
|
||||
# for field in newcpu._fields:
|
||||
# new_t = getattr(newcpu, field)
|
||||
# last_t = getattr(lastcpu, field)
|
||||
# self.assertGreaterEqual(
|
||||
# new_t, last_t, msg="%s %s" % (lastcpu, newcpu))
|
||||
# last = new
|
||||
|
||||
def test_per_cpu_times_2(self):
|
||||
# Simulate some work load then make sure time have increased
|
||||
# between calls.
|
||||
tot1 = psutil.cpu_times(percpu=True)
|
||||
giveup_at = time.time() + GLOBAL_TIMEOUT
|
||||
while True:
|
||||
if time.time() >= giveup_at:
|
||||
return self.fail("timeout")
|
||||
tot2 = psutil.cpu_times(percpu=True)
|
||||
for t1, t2 in zip(tot1, tot2):
|
||||
t1, t2 = psutil._cpu_busy_time(t1), psutil._cpu_busy_time(t2)
|
||||
difference = t2 - t1
|
||||
if difference >= 0.05:
|
||||
return
|
||||
|
||||
def test_cpu_times_comparison(self):
|
||||
# Make sure the sum of all per cpu times is almost equal to
|
||||
# base "one cpu" times.
|
||||
base = psutil.cpu_times()
|
||||
per_cpu = psutil.cpu_times(percpu=True)
|
||||
summed_values = base._make([sum(num) for num in zip(*per_cpu)])
|
||||
for field in base._fields:
|
||||
self.assertAlmostEqual(
|
||||
getattr(base, field), getattr(summed_values, field), delta=1)
|
||||
|
||||
def _test_cpu_percent(self, percent, last_ret, new_ret):
|
||||
try:
|
||||
self.assertIsInstance(percent, float)
|
||||
self.assertGreaterEqual(percent, 0.0)
|
||||
self.assertIsNot(percent, -0.0)
|
||||
self.assertLessEqual(percent, 100.0 * psutil.cpu_count())
|
||||
except AssertionError as err:
|
||||
raise AssertionError("\n%s\nlast=%s\nnew=%s" % (
|
||||
err, pprint.pformat(last_ret), pprint.pformat(new_ret)))
|
||||
|
||||
def test_cpu_percent(self):
|
||||
last = psutil.cpu_percent(interval=0.001)
|
||||
for _ in range(100):
|
||||
new = psutil.cpu_percent(interval=None)
|
||||
self._test_cpu_percent(new, last, new)
|
||||
last = new
|
||||
with self.assertRaises(ValueError):
|
||||
psutil.cpu_percent(interval=-1)
|
||||
|
||||
def test_per_cpu_percent(self):
|
||||
last = psutil.cpu_percent(interval=0.001, percpu=True)
|
||||
self.assertEqual(len(last), psutil.cpu_count())
|
||||
for _ in range(100):
|
||||
new = psutil.cpu_percent(interval=None, percpu=True)
|
||||
for percent in new:
|
||||
self._test_cpu_percent(percent, last, new)
|
||||
last = new
|
||||
with self.assertRaises(ValueError):
|
||||
psutil.cpu_percent(interval=-1, percpu=True)
|
||||
|
||||
def test_cpu_times_percent(self):
|
||||
last = psutil.cpu_times_percent(interval=0.001)
|
||||
for _ in range(100):
|
||||
new = psutil.cpu_times_percent(interval=None)
|
||||
for percent in new:
|
||||
self._test_cpu_percent(percent, last, new)
|
||||
self._test_cpu_percent(sum(new), last, new)
|
||||
last = new
|
||||
with self.assertRaises(ValueError):
|
||||
psutil.cpu_times_percent(interval=-1)
|
||||
|
||||
def test_per_cpu_times_percent(self):
|
||||
last = psutil.cpu_times_percent(interval=0.001, percpu=True)
|
||||
self.assertEqual(len(last), psutil.cpu_count())
|
||||
for _ in range(100):
|
||||
new = psutil.cpu_times_percent(interval=None, percpu=True)
|
||||
for cpu in new:
|
||||
for percent in cpu:
|
||||
self._test_cpu_percent(percent, last, new)
|
||||
self._test_cpu_percent(sum(cpu), last, new)
|
||||
last = new
|
||||
|
||||
def test_per_cpu_times_percent_negative(self):
|
||||
# see: https://github.com/giampaolo/psutil/issues/645
|
||||
psutil.cpu_times_percent(percpu=True)
|
||||
zero_times = [x._make([0 for x in range(len(x._fields))])
|
||||
for x in psutil.cpu_times(percpu=True)]
|
||||
with mock.patch('psutil.cpu_times', return_value=zero_times):
|
||||
for cpu in psutil.cpu_times_percent(percpu=True):
|
||||
for percent in cpu:
|
||||
self._test_cpu_percent(percent, None, None)
|
||||
|
||||
def test_cpu_stats(self):
|
||||
# Tested more extensively in per-platform test modules.
|
||||
infos = psutil.cpu_stats()
|
||||
self.assertEqual(
|
||||
infos._fields,
|
||||
('ctx_switches', 'interrupts', 'soft_interrupts', 'syscalls'))
|
||||
for name in infos._fields:
|
||||
value = getattr(infos, name)
|
||||
self.assertGreaterEqual(value, 0)
|
||||
# on AIX, ctx_switches is always 0
|
||||
if not AIX and name in ('ctx_switches', 'interrupts'):
|
||||
self.assertGreater(value, 0)
|
||||
|
||||
# TODO: remove this once 1892 is fixed
|
||||
@unittest.skipIf(MACOS and platform.machine() == 'arm64',
|
||||
"skipped due to #1892")
|
||||
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
|
||||
def test_cpu_freq(self):
|
||||
def check_ls(ls):
|
||||
for nt in ls:
|
||||
self.assertEqual(nt._fields, ('current', 'min', 'max'))
|
||||
if nt.max != 0.0:
|
||||
self.assertLessEqual(nt.current, nt.max)
|
||||
for name in nt._fields:
|
||||
value = getattr(nt, name)
|
||||
self.assertIsInstance(value, (int, long, float))
|
||||
self.assertGreaterEqual(value, 0)
|
||||
|
||||
ls = psutil.cpu_freq(percpu=True)
|
||||
if FREEBSD and not ls:
|
||||
raise self.skipTest("returns empty list on FreeBSD")
|
||||
|
||||
assert ls, ls
|
||||
check_ls([psutil.cpu_freq(percpu=False)])
|
||||
|
||||
if LINUX:
|
||||
self.assertEqual(len(ls), psutil.cpu_count())
|
||||
|
||||
@unittest.skipIf(not HAS_GETLOADAVG, "not supported")
|
||||
def test_getloadavg(self):
|
||||
loadavg = psutil.getloadavg()
|
||||
self.assertEqual(len(loadavg), 3)
|
||||
for load in loadavg:
|
||||
self.assertIsInstance(load, float)
|
||||
self.assertGreaterEqual(load, 0.0)
|
||||
|
||||
|
||||
class TestDiskAPIs(PsutilTestCase):
|
||||
|
||||
@unittest.skipIf(PYPY and not IS_64BIT, "unreliable on PYPY32 + 32BIT")
|
||||
def test_disk_usage(self):
|
||||
usage = psutil.disk_usage(os.getcwd())
|
||||
self.assertEqual(usage._fields, ('total', 'used', 'free', 'percent'))
|
||||
|
||||
assert usage.total > 0, usage
|
||||
assert usage.used > 0, usage
|
||||
assert usage.free > 0, usage
|
||||
assert usage.total > usage.used, usage
|
||||
assert usage.total > usage.free, usage
|
||||
assert 0 <= usage.percent <= 100, usage.percent
|
||||
if hasattr(shutil, 'disk_usage'):
|
||||
# py >= 3.3, see: http://bugs.python.org/issue12442
|
||||
shutil_usage = shutil.disk_usage(os.getcwd())
|
||||
tolerance = 5 * 1024 * 1024 # 5MB
|
||||
self.assertEqual(usage.total, shutil_usage.total)
|
||||
self.assertAlmostEqual(usage.free, shutil_usage.free,
|
||||
delta=tolerance)
|
||||
if not MACOS_12PLUS:
|
||||
# see https://github.com/giampaolo/psutil/issues/2147
|
||||
self.assertAlmostEqual(usage.used, shutil_usage.used,
|
||||
delta=tolerance)
|
||||
|
||||
# if path does not exist OSError ENOENT is expected across
|
||||
# all platforms
|
||||
fname = self.get_testfn()
|
||||
with self.assertRaises(FileNotFoundError):
|
||||
psutil.disk_usage(fname)
|
||||
|
||||
@unittest.skipIf(not ASCII_FS, "not an ASCII fs")
|
||||
def test_disk_usage_unicode(self):
|
||||
# See: https://github.com/giampaolo/psutil/issues/416
|
||||
with self.assertRaises(UnicodeEncodeError):
|
||||
psutil.disk_usage(UNICODE_SUFFIX)
|
||||
|
||||
def test_disk_usage_bytes(self):
|
||||
psutil.disk_usage(b'.')
|
||||
|
||||
def test_disk_partitions(self):
|
||||
def check_ntuple(nt):
|
||||
self.assertIsInstance(nt.device, str)
|
||||
self.assertIsInstance(nt.mountpoint, str)
|
||||
self.assertIsInstance(nt.fstype, str)
|
||||
self.assertIsInstance(nt.opts, str)
|
||||
self.assertIsInstance(nt.maxfile, (int, type(None)))
|
||||
self.assertIsInstance(nt.maxpath, (int, type(None)))
|
||||
if nt.maxfile is not None and not GITHUB_ACTIONS:
|
||||
self.assertGreater(nt.maxfile, 0)
|
||||
if nt.maxpath is not None:
|
||||
self.assertGreater(nt.maxpath, 0)
|
||||
|
||||
# all = False
|
||||
ls = psutil.disk_partitions(all=False)
|
||||
self.assertTrue(ls, msg=ls)
|
||||
for disk in ls:
|
||||
check_ntuple(disk)
|
||||
if WINDOWS and 'cdrom' in disk.opts:
|
||||
continue
|
||||
if not POSIX:
|
||||
assert os.path.exists(disk.device), disk
|
||||
else:
|
||||
# we cannot make any assumption about this, see:
|
||||
# http://goo.gl/p9c43
|
||||
disk.device
|
||||
# on modern systems mount points can also be files
|
||||
assert os.path.exists(disk.mountpoint), disk
|
||||
assert disk.fstype, disk
|
||||
|
||||
# all = True
|
||||
ls = psutil.disk_partitions(all=True)
|
||||
self.assertTrue(ls, msg=ls)
|
||||
for disk in psutil.disk_partitions(all=True):
|
||||
check_ntuple(disk)
|
||||
if not WINDOWS and disk.mountpoint:
|
||||
try:
|
||||
os.stat(disk.mountpoint)
|
||||
except OSError as err:
|
||||
if GITHUB_ACTIONS and MACOS and err.errno == errno.EIO:
|
||||
continue
|
||||
# http://mail.python.org/pipermail/python-dev/
|
||||
# 2012-June/120787.html
|
||||
if err.errno not in (errno.EPERM, errno.EACCES):
|
||||
raise
|
||||
else:
|
||||
assert os.path.exists(disk.mountpoint), disk
|
||||
|
||||
# ---
|
||||
|
||||
def find_mount_point(path):
|
||||
path = os.path.abspath(path)
|
||||
while not os.path.ismount(path):
|
||||
path = os.path.dirname(path)
|
||||
return path.lower()
|
||||
|
||||
mount = find_mount_point(__file__)
|
||||
mounts = [x.mountpoint.lower() for x in
|
||||
psutil.disk_partitions(all=True) if x.mountpoint]
|
||||
self.assertIn(mount, mounts)
|
||||
|
||||
@unittest.skipIf(LINUX and not os.path.exists('/proc/diskstats'),
|
||||
'/proc/diskstats not available on this linux version')
|
||||
@unittest.skipIf(CI_TESTING and not psutil.disk_io_counters(),
|
||||
"unreliable on CI") # no visible disks
|
||||
def test_disk_io_counters(self):
|
||||
def check_ntuple(nt):
|
||||
self.assertEqual(nt[0], nt.read_count)
|
||||
self.assertEqual(nt[1], nt.write_count)
|
||||
self.assertEqual(nt[2], nt.read_bytes)
|
||||
self.assertEqual(nt[3], nt.write_bytes)
|
||||
if not (OPENBSD or NETBSD):
|
||||
self.assertEqual(nt[4], nt.read_time)
|
||||
self.assertEqual(nt[5], nt.write_time)
|
||||
if LINUX:
|
||||
self.assertEqual(nt[6], nt.read_merged_count)
|
||||
self.assertEqual(nt[7], nt.write_merged_count)
|
||||
self.assertEqual(nt[8], nt.busy_time)
|
||||
elif FREEBSD:
|
||||
self.assertEqual(nt[6], nt.busy_time)
|
||||
for name in nt._fields:
|
||||
assert getattr(nt, name) >= 0, nt
|
||||
|
||||
ret = psutil.disk_io_counters(perdisk=False)
|
||||
assert ret is not None, "no disks on this system?"
|
||||
check_ntuple(ret)
|
||||
ret = psutil.disk_io_counters(perdisk=True)
|
||||
# make sure there are no duplicates
|
||||
self.assertEqual(len(ret), len(set(ret)))
|
||||
for key in ret:
|
||||
assert key, key
|
||||
check_ntuple(ret[key])
|
||||
|
||||
def test_disk_io_counters_no_disks(self):
|
||||
# Emulate a case where no disks are installed, see:
|
||||
# https://github.com/giampaolo/psutil/issues/1062
|
||||
with mock.patch('psutil._psplatform.disk_io_counters',
|
||||
return_value={}) as m:
|
||||
self.assertIsNone(psutil.disk_io_counters(perdisk=False))
|
||||
self.assertEqual(psutil.disk_io_counters(perdisk=True), {})
|
||||
assert m.called
|
||||
|
||||
|
||||
class TestNetAPIs(PsutilTestCase):
|
||||
|
||||
@unittest.skipIf(not HAS_NET_IO_COUNTERS, 'not supported')
|
||||
def test_net_io_counters(self):
|
||||
def check_ntuple(nt):
|
||||
self.assertEqual(nt[0], nt.bytes_sent)
|
||||
self.assertEqual(nt[1], nt.bytes_recv)
|
||||
self.assertEqual(nt[2], nt.packets_sent)
|
||||
self.assertEqual(nt[3], nt.packets_recv)
|
||||
self.assertEqual(nt[4], nt.errin)
|
||||
self.assertEqual(nt[5], nt.errout)
|
||||
self.assertEqual(nt[6], nt.dropin)
|
||||
self.assertEqual(nt[7], nt.dropout)
|
||||
assert nt.bytes_sent >= 0, nt
|
||||
assert nt.bytes_recv >= 0, nt
|
||||
assert nt.packets_sent >= 0, nt
|
||||
assert nt.packets_recv >= 0, nt
|
||||
assert nt.errin >= 0, nt
|
||||
assert nt.errout >= 0, nt
|
||||
assert nt.dropin >= 0, nt
|
||||
assert nt.dropout >= 0, nt
|
||||
|
||||
ret = psutil.net_io_counters(pernic=False)
|
||||
check_ntuple(ret)
|
||||
ret = psutil.net_io_counters(pernic=True)
|
||||
self.assertNotEqual(ret, [])
|
||||
for key in ret:
|
||||
self.assertTrue(key)
|
||||
self.assertIsInstance(key, str)
|
||||
check_ntuple(ret[key])
|
||||
|
||||
@unittest.skipIf(not HAS_NET_IO_COUNTERS, 'not supported')
|
||||
def test_net_io_counters_no_nics(self):
|
||||
# Emulate a case where no NICs are installed, see:
|
||||
# https://github.com/giampaolo/psutil/issues/1062
|
||||
with mock.patch('psutil._psplatform.net_io_counters',
|
||||
return_value={}) as m:
|
||||
self.assertIsNone(psutil.net_io_counters(pernic=False))
|
||||
self.assertEqual(psutil.net_io_counters(pernic=True), {})
|
||||
assert m.called
|
||||
|
||||
def test_net_if_addrs(self):
|
||||
nics = psutil.net_if_addrs()
|
||||
assert nics, nics
|
||||
|
||||
nic_stats = psutil.net_if_stats()
|
||||
|
||||
# Not reliable on all platforms (net_if_addrs() reports more
|
||||
# interfaces).
|
||||
# self.assertEqual(sorted(nics.keys()),
|
||||
# sorted(psutil.net_io_counters(pernic=True).keys()))
|
||||
|
||||
families = set([socket.AF_INET, socket.AF_INET6, psutil.AF_LINK])
|
||||
for nic, addrs in nics.items():
|
||||
self.assertIsInstance(nic, str)
|
||||
self.assertEqual(len(set(addrs)), len(addrs))
|
||||
for addr in addrs:
|
||||
self.assertIsInstance(addr.family, int)
|
||||
self.assertIsInstance(addr.address, str)
|
||||
self.assertIsInstance(addr.netmask, (str, type(None)))
|
||||
self.assertIsInstance(addr.broadcast, (str, type(None)))
|
||||
self.assertIn(addr.family, families)
|
||||
if sys.version_info >= (3, 4) and not PYPY:
|
||||
self.assertIsInstance(addr.family, enum.IntEnum)
|
||||
if nic_stats[nic].isup:
|
||||
# Do not test binding to addresses of interfaces
|
||||
# that are down
|
||||
if addr.family == socket.AF_INET:
|
||||
s = socket.socket(addr.family)
|
||||
with contextlib.closing(s):
|
||||
s.bind((addr.address, 0))
|
||||
elif addr.family == socket.AF_INET6:
|
||||
info = socket.getaddrinfo(
|
||||
addr.address, 0, socket.AF_INET6,
|
||||
socket.SOCK_STREAM, 0, socket.AI_PASSIVE)[0]
|
||||
af, socktype, proto, canonname, sa = info
|
||||
s = socket.socket(af, socktype, proto)
|
||||
with contextlib.closing(s):
|
||||
s.bind(sa)
|
||||
for ip in (addr.address, addr.netmask, addr.broadcast,
|
||||
addr.ptp):
|
||||
if ip is not None:
|
||||
# TODO: skip AF_INET6 for now because I get:
|
||||
# AddressValueError: Only hex digits permitted in
|
||||
# u'c6f3%lxcbr0' in u'fe80::c8e0:fff:fe54:c6f3%lxcbr0'
|
||||
if addr.family != socket.AF_INET6:
|
||||
check_net_address(ip, addr.family)
|
||||
# broadcast and ptp addresses are mutually exclusive
|
||||
if addr.broadcast:
|
||||
self.assertIsNone(addr.ptp)
|
||||
elif addr.ptp:
|
||||
self.assertIsNone(addr.broadcast)
|
||||
|
||||
if BSD or MACOS or SUNOS:
|
||||
if hasattr(socket, "AF_LINK"):
|
||||
self.assertEqual(psutil.AF_LINK, socket.AF_LINK)
|
||||
elif LINUX:
|
||||
self.assertEqual(psutil.AF_LINK, socket.AF_PACKET)
|
||||
elif WINDOWS:
|
||||
self.assertEqual(psutil.AF_LINK, -1)
|
||||
|
||||
def test_net_if_addrs_mac_null_bytes(self):
|
||||
# Simulate that the underlying C function returns an incomplete
|
||||
# MAC address. psutil is supposed to fill it with null bytes.
|
||||
# https://github.com/giampaolo/psutil/issues/786
|
||||
if POSIX:
|
||||
ret = [('em1', psutil.AF_LINK, '06:3d:29', None, None, None)]
|
||||
else:
|
||||
ret = [('em1', -1, '06-3d-29', None, None, None)]
|
||||
with mock.patch('psutil._psplatform.net_if_addrs',
|
||||
return_value=ret) as m:
|
||||
addr = psutil.net_if_addrs()['em1'][0]
|
||||
assert m.called
|
||||
if POSIX:
|
||||
self.assertEqual(addr.address, '06:3d:29:00:00:00')
|
||||
else:
|
||||
self.assertEqual(addr.address, '06-3d-29-00-00-00')
|
||||
|
||||
def test_net_if_stats(self):
|
||||
nics = psutil.net_if_stats()
|
||||
assert nics, nics
|
||||
all_duplexes = (psutil.NIC_DUPLEX_FULL,
|
||||
psutil.NIC_DUPLEX_HALF,
|
||||
psutil.NIC_DUPLEX_UNKNOWN)
|
||||
for name, stats in nics.items():
|
||||
self.assertIsInstance(name, str)
|
||||
isup, duplex, speed, mtu, flags = stats
|
||||
self.assertIsInstance(isup, bool)
|
||||
self.assertIn(duplex, all_duplexes)
|
||||
self.assertIn(duplex, all_duplexes)
|
||||
self.assertGreaterEqual(speed, 0)
|
||||
self.assertGreaterEqual(mtu, 0)
|
||||
self.assertIsInstance(flags, str)
|
||||
|
||||
@unittest.skipIf(not (LINUX or BSD or MACOS),
|
||||
"LINUX or BSD or MACOS specific")
|
||||
def test_net_if_stats_enodev(self):
|
||||
# See: https://github.com/giampaolo/psutil/issues/1279
|
||||
with mock.patch('psutil._psutil_posix.net_if_mtu',
|
||||
side_effect=OSError(errno.ENODEV, "")) as m:
|
||||
ret = psutil.net_if_stats()
|
||||
self.assertEqual(ret, {})
|
||||
assert m.called
|
||||
|
||||
|
||||
class TestSensorsAPIs(PsutilTestCase):
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_TEMPERATURES, "not supported")
|
||||
def test_sensors_temperatures(self):
|
||||
temps = psutil.sensors_temperatures()
|
||||
for name, entries in temps.items():
|
||||
self.assertIsInstance(name, str)
|
||||
for entry in entries:
|
||||
self.assertIsInstance(entry.label, str)
|
||||
if entry.current is not None:
|
||||
self.assertGreaterEqual(entry.current, 0)
|
||||
if entry.high is not None:
|
||||
self.assertGreaterEqual(entry.high, 0)
|
||||
if entry.critical is not None:
|
||||
self.assertGreaterEqual(entry.critical, 0)
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_TEMPERATURES, "not supported")
|
||||
def test_sensors_temperatures_fahreneit(self):
|
||||
d = {'coretemp': [('label', 50.0, 60.0, 70.0)]}
|
||||
with mock.patch("psutil._psplatform.sensors_temperatures",
|
||||
return_value=d) as m:
|
||||
temps = psutil.sensors_temperatures(
|
||||
fahrenheit=True)['coretemp'][0]
|
||||
assert m.called
|
||||
self.assertEqual(temps.current, 122.0)
|
||||
self.assertEqual(temps.high, 140.0)
|
||||
self.assertEqual(temps.critical, 158.0)
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_BATTERY, "not supported")
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_sensors_battery(self):
|
||||
ret = psutil.sensors_battery()
|
||||
self.assertGreaterEqual(ret.percent, 0)
|
||||
self.assertLessEqual(ret.percent, 100)
|
||||
if ret.secsleft not in (psutil.POWER_TIME_UNKNOWN,
|
||||
psutil.POWER_TIME_UNLIMITED):
|
||||
self.assertGreaterEqual(ret.secsleft, 0)
|
||||
else:
|
||||
if ret.secsleft == psutil.POWER_TIME_UNLIMITED:
|
||||
self.assertTrue(ret.power_plugged)
|
||||
self.assertIsInstance(ret.power_plugged, bool)
|
||||
|
||||
@unittest.skipIf(not HAS_SENSORS_FANS, "not supported")
|
||||
def test_sensors_fans(self):
|
||||
fans = psutil.sensors_fans()
|
||||
for name, entries in fans.items():
|
||||
self.assertIsInstance(name, str)
|
||||
for entry in entries:
|
||||
self.assertIsInstance(entry.label, str)
|
||||
self.assertIsInstance(entry.current, (int, long))
|
||||
self.assertGreaterEqual(entry.current, 0)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,445 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# 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.
|
||||
|
||||
"""
|
||||
Tests for testing utils (psutil.tests namespace).
|
||||
"""
|
||||
|
||||
import collections
|
||||
import contextlib
|
||||
import errno
|
||||
import os
|
||||
import socket
|
||||
import stat
|
||||
import subprocess
|
||||
import unittest
|
||||
|
||||
import psutil
|
||||
import psutil.tests
|
||||
from psutil import FREEBSD
|
||||
from psutil import NETBSD
|
||||
from psutil import POSIX
|
||||
from psutil._common import open_binary
|
||||
from psutil._common import open_text
|
||||
from psutil._common import supports_ipv6
|
||||
from psutil.tests import CI_TESTING
|
||||
from psutil.tests import COVERAGE
|
||||
from psutil.tests import HAS_CONNECTIONS_UNIX
|
||||
from psutil.tests import PYTHON_EXE
|
||||
from psutil.tests import PYTHON_EXE_ENV
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import TestMemoryLeak
|
||||
from psutil.tests import bind_socket
|
||||
from psutil.tests import bind_unix_socket
|
||||
from psutil.tests import call_until
|
||||
from psutil.tests import chdir
|
||||
from psutil.tests import create_sockets
|
||||
from psutil.tests import get_free_port
|
||||
from psutil.tests import is_namedtuple
|
||||
from psutil.tests import mock
|
||||
from psutil.tests import process_namespace
|
||||
from psutil.tests import reap_children
|
||||
from psutil.tests import retry
|
||||
from psutil.tests import retry_on_failure
|
||||
from psutil.tests import safe_mkdir
|
||||
from psutil.tests import safe_rmpath
|
||||
from psutil.tests import serialrun
|
||||
from psutil.tests import system_namespace
|
||||
from psutil.tests import tcp_socketpair
|
||||
from psutil.tests import terminate
|
||||
from psutil.tests import unix_socketpair
|
||||
from psutil.tests import wait_for_file
|
||||
from psutil.tests import wait_for_pid
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# --- Unit tests for test utilities.
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestRetryDecorator(PsutilTestCase):
|
||||
|
||||
@mock.patch('time.sleep')
|
||||
def test_retry_success(self, sleep):
|
||||
# Fail 3 times out of 5; make sure the decorated fun returns.
|
||||
|
||||
@retry(retries=5, interval=1, logfun=None)
|
||||
def foo():
|
||||
while queue:
|
||||
queue.pop()
|
||||
1 / 0
|
||||
return 1
|
||||
|
||||
queue = list(range(3))
|
||||
self.assertEqual(foo(), 1)
|
||||
self.assertEqual(sleep.call_count, 3)
|
||||
|
||||
@mock.patch('time.sleep')
|
||||
def test_retry_failure(self, sleep):
|
||||
# Fail 6 times out of 5; th function is supposed to raise exc.
|
||||
@retry(retries=5, interval=1, logfun=None)
|
||||
def foo():
|
||||
while queue:
|
||||
queue.pop()
|
||||
1 / 0
|
||||
return 1
|
||||
|
||||
queue = list(range(6))
|
||||
self.assertRaises(ZeroDivisionError, foo)
|
||||
self.assertEqual(sleep.call_count, 5)
|
||||
|
||||
@mock.patch('time.sleep')
|
||||
def test_exception_arg(self, sleep):
|
||||
@retry(exception=ValueError, interval=1)
|
||||
def foo():
|
||||
raise TypeError
|
||||
|
||||
self.assertRaises(TypeError, foo)
|
||||
self.assertEqual(sleep.call_count, 0)
|
||||
|
||||
@mock.patch('time.sleep')
|
||||
def test_no_interval_arg(self, sleep):
|
||||
# if interval is not specified sleep is not supposed to be called
|
||||
|
||||
@retry(retries=5, interval=None, logfun=None)
|
||||
def foo():
|
||||
1 / 0
|
||||
|
||||
self.assertRaises(ZeroDivisionError, foo)
|
||||
self.assertEqual(sleep.call_count, 0)
|
||||
|
||||
@mock.patch('time.sleep')
|
||||
def test_retries_arg(self, sleep):
|
||||
|
||||
@retry(retries=5, interval=1, logfun=None)
|
||||
def foo():
|
||||
1 / 0
|
||||
|
||||
self.assertRaises(ZeroDivisionError, foo)
|
||||
self.assertEqual(sleep.call_count, 5)
|
||||
|
||||
@mock.patch('time.sleep')
|
||||
def test_retries_and_timeout_args(self, sleep):
|
||||
self.assertRaises(ValueError, retry, retries=5, timeout=1)
|
||||
|
||||
|
||||
class TestSyncTestUtils(PsutilTestCase):
|
||||
|
||||
def test_wait_for_pid(self):
|
||||
wait_for_pid(os.getpid())
|
||||
nopid = max(psutil.pids()) + 99999
|
||||
with mock.patch('psutil.tests.retry.__iter__', return_value=iter([0])):
|
||||
self.assertRaises(psutil.NoSuchProcess, wait_for_pid, nopid)
|
||||
|
||||
def test_wait_for_file(self):
|
||||
testfn = self.get_testfn()
|
||||
with open(testfn, 'w') as f:
|
||||
f.write('foo')
|
||||
wait_for_file(testfn)
|
||||
assert not os.path.exists(testfn)
|
||||
|
||||
def test_wait_for_file_empty(self):
|
||||
testfn = self.get_testfn()
|
||||
with open(testfn, 'w'):
|
||||
pass
|
||||
wait_for_file(testfn, empty=True)
|
||||
assert not os.path.exists(testfn)
|
||||
|
||||
def test_wait_for_file_no_file(self):
|
||||
testfn = self.get_testfn()
|
||||
with mock.patch('psutil.tests.retry.__iter__', return_value=iter([0])):
|
||||
self.assertRaises(IOError, wait_for_file, testfn)
|
||||
|
||||
def test_wait_for_file_no_delete(self):
|
||||
testfn = self.get_testfn()
|
||||
with open(testfn, 'w') as f:
|
||||
f.write('foo')
|
||||
wait_for_file(testfn, delete=False)
|
||||
assert os.path.exists(testfn)
|
||||
|
||||
def test_call_until(self):
|
||||
ret = call_until(lambda: 1, "ret == 1")
|
||||
self.assertEqual(ret, 1)
|
||||
|
||||
|
||||
class TestFSTestUtils(PsutilTestCase):
|
||||
|
||||
def test_open_text(self):
|
||||
with open_text(__file__) as f:
|
||||
self.assertEqual(f.mode, 'rt')
|
||||
|
||||
def test_open_binary(self):
|
||||
with open_binary(__file__) as f:
|
||||
self.assertEqual(f.mode, 'rb')
|
||||
|
||||
def test_safe_mkdir(self):
|
||||
testfn = self.get_testfn()
|
||||
safe_mkdir(testfn)
|
||||
assert os.path.isdir(testfn)
|
||||
safe_mkdir(testfn)
|
||||
assert os.path.isdir(testfn)
|
||||
|
||||
def test_safe_rmpath(self):
|
||||
# test file is removed
|
||||
testfn = self.get_testfn()
|
||||
open(testfn, 'w').close()
|
||||
safe_rmpath(testfn)
|
||||
assert not os.path.exists(testfn)
|
||||
# test no exception if path does not exist
|
||||
safe_rmpath(testfn)
|
||||
# test dir is removed
|
||||
os.mkdir(testfn)
|
||||
safe_rmpath(testfn)
|
||||
assert not os.path.exists(testfn)
|
||||
# test other exceptions are raised
|
||||
with mock.patch('psutil.tests.os.stat',
|
||||
side_effect=OSError(errno.EINVAL, "")) as m:
|
||||
with self.assertRaises(OSError):
|
||||
safe_rmpath(testfn)
|
||||
assert m.called
|
||||
|
||||
def test_chdir(self):
|
||||
testfn = self.get_testfn()
|
||||
base = os.getcwd()
|
||||
os.mkdir(testfn)
|
||||
with chdir(testfn):
|
||||
self.assertEqual(os.getcwd(), os.path.join(base, testfn))
|
||||
self.assertEqual(os.getcwd(), base)
|
||||
|
||||
|
||||
class TestProcessUtils(PsutilTestCase):
|
||||
|
||||
def test_reap_children(self):
|
||||
subp = self.spawn_testproc()
|
||||
p = psutil.Process(subp.pid)
|
||||
assert p.is_running()
|
||||
reap_children()
|
||||
assert not p.is_running()
|
||||
assert not psutil.tests._pids_started
|
||||
assert not psutil.tests._subprocesses_started
|
||||
|
||||
def test_spawn_children_pair(self):
|
||||
child, grandchild = self.spawn_children_pair()
|
||||
self.assertNotEqual(child.pid, grandchild.pid)
|
||||
assert child.is_running()
|
||||
assert grandchild.is_running()
|
||||
children = psutil.Process().children()
|
||||
self.assertEqual(children, [child])
|
||||
children = psutil.Process().children(recursive=True)
|
||||
self.assertEqual(len(children), 2)
|
||||
self.assertIn(child, children)
|
||||
self.assertIn(grandchild, children)
|
||||
self.assertEqual(child.ppid(), os.getpid())
|
||||
self.assertEqual(grandchild.ppid(), child.pid)
|
||||
|
||||
terminate(child)
|
||||
assert not child.is_running()
|
||||
assert grandchild.is_running()
|
||||
|
||||
terminate(grandchild)
|
||||
assert not grandchild.is_running()
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
def test_spawn_zombie(self):
|
||||
parent, zombie = self.spawn_zombie()
|
||||
self.assertEqual(zombie.status(), psutil.STATUS_ZOMBIE)
|
||||
|
||||
def test_terminate(self):
|
||||
# by subprocess.Popen
|
||||
p = self.spawn_testproc()
|
||||
terminate(p)
|
||||
self.assertProcessGone(p)
|
||||
terminate(p)
|
||||
# by psutil.Process
|
||||
p = psutil.Process(self.spawn_testproc().pid)
|
||||
terminate(p)
|
||||
self.assertProcessGone(p)
|
||||
terminate(p)
|
||||
# by psutil.Popen
|
||||
cmd = [PYTHON_EXE, "-c", "import time; time.sleep(60);"]
|
||||
p = psutil.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
||||
env=PYTHON_EXE_ENV)
|
||||
terminate(p)
|
||||
self.assertProcessGone(p)
|
||||
terminate(p)
|
||||
# by PID
|
||||
pid = self.spawn_testproc().pid
|
||||
terminate(pid)
|
||||
self.assertProcessGone(p)
|
||||
terminate(pid)
|
||||
# zombie
|
||||
if POSIX:
|
||||
parent, zombie = self.spawn_zombie()
|
||||
terminate(parent)
|
||||
terminate(zombie)
|
||||
self.assertProcessGone(parent)
|
||||
self.assertProcessGone(zombie)
|
||||
|
||||
|
||||
class TestNetUtils(PsutilTestCase):
|
||||
|
||||
def bind_socket(self):
|
||||
port = get_free_port()
|
||||
with contextlib.closing(bind_socket(addr=('', port))) as s:
|
||||
self.assertEqual(s.getsockname()[1], port)
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
def test_bind_unix_socket(self):
|
||||
name = self.get_testfn()
|
||||
sock = bind_unix_socket(name)
|
||||
with contextlib.closing(sock):
|
||||
self.assertEqual(sock.family, socket.AF_UNIX)
|
||||
self.assertEqual(sock.type, socket.SOCK_STREAM)
|
||||
self.assertEqual(sock.getsockname(), name)
|
||||
assert os.path.exists(name)
|
||||
assert stat.S_ISSOCK(os.stat(name).st_mode)
|
||||
# UDP
|
||||
name = self.get_testfn()
|
||||
sock = bind_unix_socket(name, type=socket.SOCK_DGRAM)
|
||||
with contextlib.closing(sock):
|
||||
self.assertEqual(sock.type, socket.SOCK_DGRAM)
|
||||
|
||||
def tcp_tcp_socketpair(self):
|
||||
addr = ("127.0.0.1", get_free_port())
|
||||
server, client = tcp_socketpair(socket.AF_INET, addr=addr)
|
||||
with contextlib.closing(server):
|
||||
with contextlib.closing(client):
|
||||
# Ensure they are connected and the positions are
|
||||
# correct.
|
||||
self.assertEqual(server.getsockname(), addr)
|
||||
self.assertEqual(client.getpeername(), addr)
|
||||
self.assertNotEqual(client.getsockname(), addr)
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
@unittest.skipIf(NETBSD or FREEBSD,
|
||||
"/var/run/log UNIX socket opened by default")
|
||||
def test_unix_socketpair(self):
|
||||
p = psutil.Process()
|
||||
num_fds = p.num_fds()
|
||||
assert not p.connections(kind='unix')
|
||||
name = self.get_testfn()
|
||||
server, client = unix_socketpair(name)
|
||||
try:
|
||||
assert os.path.exists(name)
|
||||
assert stat.S_ISSOCK(os.stat(name).st_mode)
|
||||
self.assertEqual(p.num_fds() - num_fds, 2)
|
||||
self.assertEqual(len(p.connections(kind='unix')), 2)
|
||||
self.assertEqual(server.getsockname(), name)
|
||||
self.assertEqual(client.getpeername(), name)
|
||||
finally:
|
||||
client.close()
|
||||
server.close()
|
||||
|
||||
def test_create_sockets(self):
|
||||
with create_sockets() as socks:
|
||||
fams = collections.defaultdict(int)
|
||||
types = collections.defaultdict(int)
|
||||
for s in socks:
|
||||
fams[s.family] += 1
|
||||
# work around http://bugs.python.org/issue30204
|
||||
types[s.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE)] += 1
|
||||
self.assertGreaterEqual(fams[socket.AF_INET], 2)
|
||||
if supports_ipv6():
|
||||
self.assertGreaterEqual(fams[socket.AF_INET6], 2)
|
||||
if POSIX and HAS_CONNECTIONS_UNIX:
|
||||
self.assertGreaterEqual(fams[socket.AF_UNIX], 2)
|
||||
self.assertGreaterEqual(types[socket.SOCK_STREAM], 2)
|
||||
self.assertGreaterEqual(types[socket.SOCK_DGRAM], 2)
|
||||
|
||||
|
||||
@serialrun
|
||||
class TestMemLeakClass(TestMemoryLeak):
|
||||
|
||||
@retry_on_failure()
|
||||
def test_times(self):
|
||||
def fun():
|
||||
cnt['cnt'] += 1
|
||||
cnt = {'cnt': 0}
|
||||
self.execute(fun, times=10, warmup_times=15)
|
||||
self.assertEqual(cnt['cnt'], 26)
|
||||
|
||||
def test_param_err(self):
|
||||
self.assertRaises(ValueError, self.execute, lambda: 0, times=0)
|
||||
self.assertRaises(ValueError, self.execute, lambda: 0, times=-1)
|
||||
self.assertRaises(ValueError, self.execute, lambda: 0, warmup_times=-1)
|
||||
self.assertRaises(ValueError, self.execute, lambda: 0, tolerance=-1)
|
||||
self.assertRaises(ValueError, self.execute, lambda: 0, retries=-1)
|
||||
|
||||
@retry_on_failure()
|
||||
@unittest.skipIf(CI_TESTING, "skipped on CI")
|
||||
@unittest.skipIf(COVERAGE, "skipped during test coverage")
|
||||
def test_leak_mem(self):
|
||||
ls = []
|
||||
|
||||
def fun(ls=ls):
|
||||
ls.append("x" * 24 * 1024)
|
||||
|
||||
try:
|
||||
# will consume around 3M in total
|
||||
self.assertRaisesRegex(AssertionError, "extra-mem",
|
||||
self.execute, fun, times=50)
|
||||
finally:
|
||||
del ls
|
||||
|
||||
def test_unclosed_files(self):
|
||||
def fun():
|
||||
f = open(__file__)
|
||||
self.addCleanup(f.close)
|
||||
box.append(f)
|
||||
|
||||
box = []
|
||||
kind = "fd" if POSIX else "handle"
|
||||
self.assertRaisesRegex(AssertionError, "unclosed " + kind,
|
||||
self.execute, fun)
|
||||
|
||||
def test_tolerance(self):
|
||||
def fun():
|
||||
ls.append("x" * 24 * 1024)
|
||||
ls = []
|
||||
times = 100
|
||||
self.execute(fun, times=times, warmup_times=0,
|
||||
tolerance=200 * 1024 * 1024)
|
||||
self.assertEqual(len(ls), times + 1)
|
||||
|
||||
def test_execute_w_exc(self):
|
||||
def fun_1():
|
||||
1 / 0
|
||||
self.execute_w_exc(ZeroDivisionError, fun_1)
|
||||
with self.assertRaises(ZeroDivisionError):
|
||||
self.execute_w_exc(OSError, fun_1)
|
||||
|
||||
def fun_2():
|
||||
pass
|
||||
with self.assertRaises(AssertionError):
|
||||
self.execute_w_exc(ZeroDivisionError, fun_2)
|
||||
|
||||
|
||||
class TestTestingUtils(PsutilTestCase):
|
||||
|
||||
def test_process_namespace(self):
|
||||
p = psutil.Process()
|
||||
ns = process_namespace(p)
|
||||
ns.test()
|
||||
fun = [x for x in ns.iter(ns.getters) if x[1] == 'ppid'][0][0]
|
||||
self.assertEqual(fun(), p.ppid())
|
||||
|
||||
def test_system_namespace(self):
|
||||
ns = system_namespace()
|
||||
fun = [x for x in ns.iter(ns.getters) if x[1] == 'net_if_addrs'][0][0]
|
||||
self.assertEqual(fun(), psutil.net_if_addrs())
|
||||
|
||||
|
||||
class TestOtherUtils(PsutilTestCase):
|
||||
|
||||
def test_is_namedtuple(self):
|
||||
assert is_namedtuple(collections.namedtuple('foo', 'a b c')(1, 2, 3))
|
||||
assert not is_namedtuple(tuple())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,349 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# 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.
|
||||
|
||||
"""
|
||||
Notes about unicode handling in psutil
|
||||
======================================
|
||||
|
||||
Starting from version 5.3.0 psutil adds unicode support, see:
|
||||
https://github.com/giampaolo/psutil/issues/1040
|
||||
The notes below apply to *any* API returning a string such as
|
||||
process exe(), cwd() or username():
|
||||
|
||||
* all strings are encoded by using the OS filesystem encoding
|
||||
(sys.getfilesystemencoding()) which varies depending on the platform
|
||||
(e.g. "UTF-8" on macOS, "mbcs" on Win)
|
||||
* no API call is supposed to crash with UnicodeDecodeError
|
||||
* instead, in case of badly encoded data returned by the OS, the
|
||||
following error handlers are used to replace the corrupted characters in
|
||||
the string:
|
||||
* Python 3: sys.getfilesystemencodeerrors() (PY 3.6+) or
|
||||
"surrogatescape" on POSIX and "replace" on Windows
|
||||
* Python 2: "replace"
|
||||
* on Python 2 all APIs return bytes (str type), never unicode
|
||||
* on Python 2, you can go back to unicode by doing:
|
||||
|
||||
>>> unicode(p.exe(), sys.getdefaultencoding(), errors="replace")
|
||||
|
||||
For a detailed explanation of how psutil handles unicode see #1040.
|
||||
|
||||
Tests
|
||||
=====
|
||||
|
||||
List of APIs returning or dealing with a string:
|
||||
('not tested' means they are not tested to deal with non-ASCII strings):
|
||||
|
||||
* Process.cmdline()
|
||||
* Process.connections('unix')
|
||||
* Process.cwd()
|
||||
* Process.environ()
|
||||
* Process.exe()
|
||||
* Process.memory_maps()
|
||||
* Process.name()
|
||||
* Process.open_files()
|
||||
* Process.username() (not tested)
|
||||
|
||||
* disk_io_counters() (not tested)
|
||||
* disk_partitions() (not tested)
|
||||
* disk_usage(str)
|
||||
* net_connections('unix')
|
||||
* net_if_addrs() (not tested)
|
||||
* net_if_stats() (not tested)
|
||||
* net_io_counters() (not tested)
|
||||
* sensors_fans() (not tested)
|
||||
* sensors_temperatures() (not tested)
|
||||
* users() (not tested)
|
||||
|
||||
* WindowsService.binpath() (not tested)
|
||||
* WindowsService.description() (not tested)
|
||||
* WindowsService.display_name() (not tested)
|
||||
* WindowsService.name() (not tested)
|
||||
* WindowsService.status() (not tested)
|
||||
* WindowsService.username() (not tested)
|
||||
|
||||
In here we create a unicode path with a funky non-ASCII name and (where
|
||||
possible) make psutil return it back (e.g. on name(), exe(), open_files(),
|
||||
etc.) and make sure that:
|
||||
|
||||
* psutil never crashes with UnicodeDecodeError
|
||||
* the returned path matches
|
||||
"""
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import traceback
|
||||
import unittest
|
||||
import warnings
|
||||
from contextlib import closing
|
||||
|
||||
import psutil
|
||||
from psutil import BSD
|
||||
from psutil import POSIX
|
||||
from psutil import WINDOWS
|
||||
from psutil._compat import PY3
|
||||
from psutil._compat import u
|
||||
from psutil.tests import APPVEYOR
|
||||
from psutil.tests import ASCII_FS
|
||||
from psutil.tests import CI_TESTING
|
||||
from psutil.tests import HAS_CONNECTIONS_UNIX
|
||||
from psutil.tests import HAS_ENVIRON
|
||||
from psutil.tests import HAS_MEMORY_MAPS
|
||||
from psutil.tests import INVALID_UNICODE_SUFFIX
|
||||
from psutil.tests import PYPY
|
||||
from psutil.tests import TESTFN_PREFIX
|
||||
from psutil.tests import UNICODE_SUFFIX
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import bind_unix_socket
|
||||
from psutil.tests import chdir
|
||||
from psutil.tests import copyload_shared_lib
|
||||
from psutil.tests import create_exe
|
||||
from psutil.tests import get_testfn
|
||||
from psutil.tests import safe_mkdir
|
||||
from psutil.tests import safe_rmpath
|
||||
from psutil.tests import serialrun
|
||||
from psutil.tests import skip_on_access_denied
|
||||
from psutil.tests import spawn_testproc
|
||||
from psutil.tests import terminate
|
||||
|
||||
|
||||
if APPVEYOR:
|
||||
def safe_rmpath(path): # NOQA
|
||||
# TODO - this is quite random and I'm not sure why it happens,
|
||||
# nor I can reproduce it locally:
|
||||
# https://ci.appveyor.com/project/giampaolo/psutil/build/job/
|
||||
# jiq2cgd6stsbtn60
|
||||
# safe_rmpath() happens after reap_children() so this is weird
|
||||
# Perhaps wait_procs() on Windows is broken? Maybe because
|
||||
# of STILL_ACTIVE?
|
||||
# https://github.com/giampaolo/psutil/blob/
|
||||
# 68c7a70728a31d8b8b58f4be6c4c0baa2f449eda/psutil/arch/
|
||||
# windows/process_info.c#L146
|
||||
from psutil.tests import safe_rmpath as rm
|
||||
try:
|
||||
return rm(path)
|
||||
except WindowsError:
|
||||
traceback.print_exc()
|
||||
|
||||
|
||||
def try_unicode(suffix):
|
||||
"""Return True if both the fs and the subprocess module can
|
||||
deal with a unicode file name.
|
||||
"""
|
||||
sproc = None
|
||||
testfn = get_testfn(suffix=suffix)
|
||||
try:
|
||||
safe_rmpath(testfn)
|
||||
create_exe(testfn)
|
||||
sproc = spawn_testproc(cmd=[testfn])
|
||||
shutil.copyfile(testfn, testfn + '-2')
|
||||
safe_rmpath(testfn + '-2')
|
||||
except (UnicodeEncodeError, IOError):
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
finally:
|
||||
if sproc is not None:
|
||||
terminate(sproc)
|
||||
safe_rmpath(testfn)
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# FS APIs
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class BaseUnicodeTest(PsutilTestCase):
|
||||
funky_suffix = None
|
||||
|
||||
def setUp(self):
|
||||
if self.funky_suffix is not None:
|
||||
if not try_unicode(self.funky_suffix):
|
||||
raise self.skipTest("can't handle unicode str")
|
||||
|
||||
|
||||
@serialrun
|
||||
@unittest.skipIf(ASCII_FS, "ASCII fs")
|
||||
@unittest.skipIf(PYPY and not PY3, "too much trouble on PYPY2")
|
||||
class TestFSAPIs(BaseUnicodeTest):
|
||||
"""Test FS APIs with a funky, valid, UTF8 path name."""
|
||||
|
||||
funky_suffix = UNICODE_SUFFIX
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.funky_name = get_testfn(suffix=cls.funky_suffix)
|
||||
create_exe(cls.funky_name)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
safe_rmpath(cls.funky_name)
|
||||
|
||||
def expect_exact_path_match(self):
|
||||
# Do not expect psutil to correctly handle unicode paths on
|
||||
# Python 2 if os.listdir() is not able either.
|
||||
here = '.' if isinstance(self.funky_name, str) else u('.')
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("ignore")
|
||||
return self.funky_name in os.listdir(here)
|
||||
|
||||
# ---
|
||||
|
||||
def test_proc_exe(self):
|
||||
subp = self.spawn_testproc(cmd=[self.funky_name])
|
||||
p = psutil.Process(subp.pid)
|
||||
exe = p.exe()
|
||||
self.assertIsInstance(exe, str)
|
||||
if self.expect_exact_path_match():
|
||||
self.assertEqual(os.path.normcase(exe),
|
||||
os.path.normcase(self.funky_name))
|
||||
|
||||
def test_proc_name(self):
|
||||
subp = self.spawn_testproc(cmd=[self.funky_name])
|
||||
name = psutil.Process(subp.pid).name()
|
||||
self.assertIsInstance(name, str)
|
||||
if self.expect_exact_path_match():
|
||||
self.assertEqual(name, os.path.basename(self.funky_name))
|
||||
|
||||
def test_proc_cmdline(self):
|
||||
subp = self.spawn_testproc(cmd=[self.funky_name])
|
||||
p = psutil.Process(subp.pid)
|
||||
cmdline = p.cmdline()
|
||||
for part in cmdline:
|
||||
self.assertIsInstance(part, str)
|
||||
if self.expect_exact_path_match():
|
||||
self.assertEqual(cmdline, [self.funky_name])
|
||||
|
||||
def test_proc_cwd(self):
|
||||
dname = self.funky_name + "2"
|
||||
self.addCleanup(safe_rmpath, dname)
|
||||
safe_mkdir(dname)
|
||||
with chdir(dname):
|
||||
p = psutil.Process()
|
||||
cwd = p.cwd()
|
||||
self.assertIsInstance(p.cwd(), str)
|
||||
if self.expect_exact_path_match():
|
||||
self.assertEqual(cwd, dname)
|
||||
|
||||
@unittest.skipIf(PYPY and WINDOWS, "fails on PYPY + WINDOWS")
|
||||
def test_proc_open_files(self):
|
||||
p = psutil.Process()
|
||||
start = set(p.open_files())
|
||||
with open(self.funky_name, 'rb'):
|
||||
new = set(p.open_files())
|
||||
path = (new - start).pop().path
|
||||
self.assertIsInstance(path, str)
|
||||
if BSD and not path:
|
||||
# XXX - see https://github.com/giampaolo/psutil/issues/595
|
||||
return self.skipTest("open_files on BSD is broken")
|
||||
if self.expect_exact_path_match():
|
||||
self.assertEqual(os.path.normcase(path),
|
||||
os.path.normcase(self.funky_name))
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
def test_proc_connections(self):
|
||||
name = self.get_testfn(suffix=self.funky_suffix)
|
||||
try:
|
||||
sock = bind_unix_socket(name)
|
||||
except UnicodeEncodeError:
|
||||
if PY3:
|
||||
raise
|
||||
else:
|
||||
raise unittest.SkipTest("not supported")
|
||||
with closing(sock):
|
||||
conn = psutil.Process().connections('unix')[0]
|
||||
self.assertIsInstance(conn.laddr, str)
|
||||
self.assertEqual(conn.laddr, name)
|
||||
|
||||
@unittest.skipIf(not POSIX, "POSIX only")
|
||||
@unittest.skipIf(not HAS_CONNECTIONS_UNIX, "can't list UNIX sockets")
|
||||
@skip_on_access_denied()
|
||||
def test_net_connections(self):
|
||||
def find_sock(cons):
|
||||
for conn in cons:
|
||||
if os.path.basename(conn.laddr).startswith(TESTFN_PREFIX):
|
||||
return conn
|
||||
raise ValueError("connection not found")
|
||||
|
||||
name = self.get_testfn(suffix=self.funky_suffix)
|
||||
try:
|
||||
sock = bind_unix_socket(name)
|
||||
except UnicodeEncodeError:
|
||||
if PY3:
|
||||
raise
|
||||
else:
|
||||
raise unittest.SkipTest("not supported")
|
||||
with closing(sock):
|
||||
cons = psutil.net_connections(kind='unix')
|
||||
conn = find_sock(cons)
|
||||
self.assertIsInstance(conn.laddr, str)
|
||||
self.assertEqual(conn.laddr, name)
|
||||
|
||||
def test_disk_usage(self):
|
||||
dname = self.funky_name + "2"
|
||||
self.addCleanup(safe_rmpath, dname)
|
||||
safe_mkdir(dname)
|
||||
psutil.disk_usage(dname)
|
||||
|
||||
@unittest.skipIf(not HAS_MEMORY_MAPS, "not supported")
|
||||
@unittest.skipIf(not PY3, "ctypes does not support unicode on PY2")
|
||||
@unittest.skipIf(PYPY, "unstable on PYPY")
|
||||
def test_memory_maps(self):
|
||||
# XXX: on Python 2, using ctypes.CDLL with a unicode path
|
||||
# opens a message box which blocks the test run.
|
||||
with copyload_shared_lib(suffix=self.funky_suffix) as funky_path:
|
||||
def normpath(p):
|
||||
return os.path.realpath(os.path.normcase(p))
|
||||
libpaths = [normpath(x.path)
|
||||
for x in psutil.Process().memory_maps()]
|
||||
# ...just to have a clearer msg in case of failure
|
||||
libpaths = [x for x in libpaths if TESTFN_PREFIX in x]
|
||||
self.assertIn(normpath(funky_path), libpaths)
|
||||
for path in libpaths:
|
||||
self.assertIsInstance(path, str)
|
||||
|
||||
|
||||
@unittest.skipIf(CI_TESTING, "unreliable on CI")
|
||||
class TestFSAPIsWithInvalidPath(TestFSAPIs):
|
||||
"""Test FS APIs with a funky, invalid path name."""
|
||||
funky_suffix = INVALID_UNICODE_SUFFIX
|
||||
|
||||
def expect_exact_path_match(self):
|
||||
# Invalid unicode names are supposed to work on Python 2.
|
||||
return True
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# Non fs APIs
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestNonFSAPIS(BaseUnicodeTest):
|
||||
"""Unicode tests for non fs-related APIs."""
|
||||
funky_suffix = UNICODE_SUFFIX if PY3 else 'è'
|
||||
|
||||
@unittest.skipIf(not HAS_ENVIRON, "not supported")
|
||||
@unittest.skipIf(PYPY and WINDOWS, "segfaults on PYPY + WINDOWS")
|
||||
def test_proc_environ(self):
|
||||
# Note: differently from others, this test does not deal
|
||||
# with fs paths. On Python 2 subprocess module is broken as
|
||||
# it's not able to handle with non-ASCII env vars, so
|
||||
# we use "è", which is part of the extended ASCII table
|
||||
# (unicode point <= 255).
|
||||
env = os.environ.copy()
|
||||
env['FUNNY_ARG'] = self.funky_suffix
|
||||
sproc = self.spawn_testproc(env=env)
|
||||
p = psutil.Process(sproc.pid)
|
||||
env = p.environ()
|
||||
for k, v in env.items():
|
||||
self.assertIsInstance(k, str)
|
||||
self.assertIsInstance(v, str)
|
||||
self.assertEqual(env['FUNNY_ARG'], self.funky_suffix)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
|
@ -0,0 +1,898 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: UTF-8 -*
|
||||
|
||||
# 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.
|
||||
|
||||
"""Windows specific tests."""
|
||||
|
||||
import datetime
|
||||
import errno
|
||||
import glob
|
||||
import os
|
||||
import platform
|
||||
import re
|
||||
import signal
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import unittest
|
||||
import warnings
|
||||
|
||||
import psutil
|
||||
from psutil import WINDOWS
|
||||
from psutil._compat import FileNotFoundError
|
||||
from psutil._compat import super
|
||||
from psutil._compat import which
|
||||
from psutil.tests import APPVEYOR
|
||||
from psutil.tests import GITHUB_ACTIONS
|
||||
from psutil.tests import HAS_BATTERY
|
||||
from psutil.tests import IS_64BIT
|
||||
from psutil.tests import PY3
|
||||
from psutil.tests import PYPY
|
||||
from psutil.tests import TOLERANCE_DISK_USAGE
|
||||
from psutil.tests import TOLERANCE_SYS_MEM
|
||||
from psutil.tests import PsutilTestCase
|
||||
from psutil.tests import mock
|
||||
from psutil.tests import retry_on_failure
|
||||
from psutil.tests import sh
|
||||
from psutil.tests import spawn_testproc
|
||||
from psutil.tests import terminate
|
||||
|
||||
|
||||
if WINDOWS and not PYPY:
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("ignore")
|
||||
import win32api # requires "pip install pywin32"
|
||||
import win32con
|
||||
import win32process
|
||||
import wmi # requires "pip install wmi" / "make setup-dev-env"
|
||||
|
||||
if WINDOWS:
|
||||
from psutil._pswindows import convert_oserror
|
||||
|
||||
|
||||
cext = psutil._psplatform.cext
|
||||
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
@unittest.skipIf(PYPY, "pywin32 not available on PYPY")
|
||||
# https://github.com/giampaolo/psutil/pull/1762#issuecomment-632892692
|
||||
@unittest.skipIf(GITHUB_ACTIONS and not PY3, "pywin32 broken on GITHUB + PY2")
|
||||
class WindowsTestCase(PsutilTestCase):
|
||||
pass
|
||||
|
||||
|
||||
def powershell(cmd):
|
||||
"""Currently not used, but avalable just in case. Usage:
|
||||
|
||||
>>> powershell(
|
||||
"Get-CIMInstance Win32_PageFileUsage | Select AllocatedBaseSize")
|
||||
"""
|
||||
if not which("powershell.exe"):
|
||||
raise unittest.SkipTest("powershell.exe not available")
|
||||
cmdline = \
|
||||
'powershell.exe -ExecutionPolicy Bypass -NoLogo -NonInteractive ' + \
|
||||
'-NoProfile -WindowStyle Hidden -Command "%s"' % cmd
|
||||
return sh(cmdline)
|
||||
|
||||
|
||||
def wmic(path, what, converter=int):
|
||||
"""Currently not used, but avalable just in case. Usage:
|
||||
|
||||
>>> wmic("Win32_OperatingSystem", "FreePhysicalMemory")
|
||||
2134124534
|
||||
"""
|
||||
out = sh("wmic path %s get %s" % (path, what)).strip()
|
||||
data = "".join(out.splitlines()[1:]).strip() # get rid of the header
|
||||
if converter is not None:
|
||||
if "," in what:
|
||||
return tuple([converter(x) for x in data.split()])
|
||||
else:
|
||||
return converter(data)
|
||||
else:
|
||||
return data
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# System APIs
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestCpuAPIs(WindowsTestCase):
|
||||
|
||||
@unittest.skipIf('NUMBER_OF_PROCESSORS' not in os.environ,
|
||||
'NUMBER_OF_PROCESSORS env var is not available')
|
||||
def test_cpu_count_vs_NUMBER_OF_PROCESSORS(self):
|
||||
# Will likely fail on many-cores systems:
|
||||
# https://stackoverflow.com/questions/31209256
|
||||
num_cpus = int(os.environ['NUMBER_OF_PROCESSORS'])
|
||||
self.assertEqual(num_cpus, psutil.cpu_count())
|
||||
|
||||
def test_cpu_count_vs_GetSystemInfo(self):
|
||||
# Will likely fail on many-cores systems:
|
||||
# https://stackoverflow.com/questions/31209256
|
||||
sys_value = win32api.GetSystemInfo()[5]
|
||||
psutil_value = psutil.cpu_count()
|
||||
self.assertEqual(sys_value, psutil_value)
|
||||
|
||||
def test_cpu_count_logical_vs_wmi(self):
|
||||
w = wmi.WMI()
|
||||
procs = sum(proc.NumberOfLogicalProcessors
|
||||
for proc in w.Win32_Processor())
|
||||
self.assertEqual(psutil.cpu_count(), procs)
|
||||
|
||||
def test_cpu_count_cores_vs_wmi(self):
|
||||
w = wmi.WMI()
|
||||
cores = sum(proc.NumberOfCores for proc in w.Win32_Processor())
|
||||
self.assertEqual(psutil.cpu_count(logical=False), cores)
|
||||
|
||||
def test_cpu_count_vs_cpu_times(self):
|
||||
self.assertEqual(psutil.cpu_count(),
|
||||
len(psutil.cpu_times(percpu=True)))
|
||||
|
||||
def test_cpu_freq(self):
|
||||
w = wmi.WMI()
|
||||
proc = w.Win32_Processor()[0]
|
||||
self.assertEqual(proc.CurrentClockSpeed, psutil.cpu_freq().current)
|
||||
self.assertEqual(proc.MaxClockSpeed, psutil.cpu_freq().max)
|
||||
|
||||
|
||||
class TestSystemAPIs(WindowsTestCase):
|
||||
|
||||
def test_nic_names(self):
|
||||
out = sh('ipconfig /all')
|
||||
nics = psutil.net_io_counters(pernic=True).keys()
|
||||
for nic in nics:
|
||||
if "pseudo-interface" in nic.replace(' ', '-').lower():
|
||||
continue
|
||||
if nic not in out:
|
||||
raise self.fail(
|
||||
"%r nic wasn't found in 'ipconfig /all' output" % nic)
|
||||
|
||||
def test_total_phymem(self):
|
||||
w = wmi.WMI().Win32_ComputerSystem()[0]
|
||||
self.assertEqual(int(w.TotalPhysicalMemory),
|
||||
psutil.virtual_memory().total)
|
||||
|
||||
def test_free_phymem(self):
|
||||
w = wmi.WMI().Win32_PerfRawData_PerfOS_Memory()[0]
|
||||
self.assertAlmostEqual(
|
||||
int(w.AvailableBytes), psutil.virtual_memory().free,
|
||||
delta=TOLERANCE_SYS_MEM)
|
||||
|
||||
def test_total_swapmem(self):
|
||||
w = wmi.WMI().Win32_PerfRawData_PerfOS_Memory()[0]
|
||||
self.assertEqual(int(w.CommitLimit) - psutil.virtual_memory().total,
|
||||
psutil.swap_memory().total)
|
||||
if (psutil.swap_memory().total == 0):
|
||||
self.assertEqual(0, psutil.swap_memory().free)
|
||||
self.assertEqual(0, psutil.swap_memory().used)
|
||||
|
||||
def test_percent_swapmem(self):
|
||||
if (psutil.swap_memory().total > 0):
|
||||
w = wmi.WMI().Win32_PerfRawData_PerfOS_PagingFile(
|
||||
Name="_Total")[0]
|
||||
# calculate swap usage to percent
|
||||
percentSwap = int(w.PercentUsage) * 100 / int(w.PercentUsage_Base)
|
||||
# exact percent may change but should be reasonable
|
||||
# assert within +/- 5% and between 0 and 100%
|
||||
self.assertGreaterEqual(psutil.swap_memory().percent, 0)
|
||||
self.assertAlmostEqual(psutil.swap_memory().percent, percentSwap,
|
||||
delta=5)
|
||||
self.assertLessEqual(psutil.swap_memory().percent, 100)
|
||||
|
||||
# @unittest.skipIf(wmi is None, "wmi module is not installed")
|
||||
# def test__UPTIME(self):
|
||||
# # _UPTIME constant is not public but it is used internally
|
||||
# # as value to return for pid 0 creation time.
|
||||
# # WMI behaves the same.
|
||||
# w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
# p = psutil.Process(0)
|
||||
# wmic_create = str(w.CreationDate.split('.')[0])
|
||||
# psutil_create = time.strftime("%Y%m%d%H%M%S",
|
||||
# time.localtime(p.create_time()))
|
||||
|
||||
# Note: this test is not very reliable
|
||||
@unittest.skipIf(APPVEYOR, "test not relieable on appveyor")
|
||||
@retry_on_failure()
|
||||
def test_pids(self):
|
||||
# Note: this test might fail if the OS is starting/killing
|
||||
# other processes in the meantime
|
||||
w = wmi.WMI().Win32_Process()
|
||||
wmi_pids = set([x.ProcessId for x in w])
|
||||
psutil_pids = set(psutil.pids())
|
||||
self.assertEqual(wmi_pids, psutil_pids)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_disks(self):
|
||||
ps_parts = psutil.disk_partitions(all=True)
|
||||
wmi_parts = wmi.WMI().Win32_LogicalDisk()
|
||||
for ps_part in ps_parts:
|
||||
for wmi_part in wmi_parts:
|
||||
if ps_part.device.replace('\\', '') == wmi_part.DeviceID:
|
||||
if not ps_part.mountpoint:
|
||||
# this is usually a CD-ROM with no disk inserted
|
||||
break
|
||||
if 'cdrom' in ps_part.opts:
|
||||
break
|
||||
if ps_part.mountpoint.startswith('A:'):
|
||||
break # floppy
|
||||
try:
|
||||
usage = psutil.disk_usage(ps_part.mountpoint)
|
||||
except FileNotFoundError:
|
||||
# usually this is the floppy
|
||||
break
|
||||
self.assertEqual(usage.total, int(wmi_part.Size))
|
||||
wmi_free = int(wmi_part.FreeSpace)
|
||||
self.assertEqual(usage.free, wmi_free)
|
||||
# 10 MB tolerance
|
||||
if abs(usage.free - wmi_free) > 10 * 1024 * 1024:
|
||||
raise self.fail("psutil=%s, wmi=%s" % (
|
||||
usage.free, wmi_free))
|
||||
break
|
||||
else:
|
||||
raise self.fail("can't find partition %s" % repr(ps_part))
|
||||
|
||||
@retry_on_failure()
|
||||
def test_disk_usage(self):
|
||||
for disk in psutil.disk_partitions():
|
||||
if 'cdrom' in disk.opts:
|
||||
continue
|
||||
sys_value = win32api.GetDiskFreeSpaceEx(disk.mountpoint)
|
||||
psutil_value = psutil.disk_usage(disk.mountpoint)
|
||||
self.assertAlmostEqual(sys_value[0], psutil_value.free,
|
||||
delta=TOLERANCE_DISK_USAGE)
|
||||
self.assertAlmostEqual(sys_value[1], psutil_value.total,
|
||||
delta=TOLERANCE_DISK_USAGE)
|
||||
self.assertEqual(psutil_value.used,
|
||||
psutil_value.total - psutil_value.free)
|
||||
|
||||
def test_disk_partitions(self):
|
||||
sys_value = [
|
||||
x + '\\' for x in win32api.GetLogicalDriveStrings().split("\\\x00")
|
||||
if x and not x.startswith('A:')]
|
||||
psutil_value = [x.mountpoint for x in psutil.disk_partitions(all=True)
|
||||
if not x.mountpoint.startswith('A:')]
|
||||
self.assertEqual(sys_value, psutil_value)
|
||||
|
||||
def test_net_if_stats(self):
|
||||
ps_names = set(cext.net_if_stats())
|
||||
wmi_adapters = wmi.WMI().Win32_NetworkAdapter()
|
||||
wmi_names = set()
|
||||
for wmi_adapter in wmi_adapters:
|
||||
wmi_names.add(wmi_adapter.Name)
|
||||
wmi_names.add(wmi_adapter.NetConnectionID)
|
||||
self.assertTrue(ps_names & wmi_names,
|
||||
"no common entries in %s, %s" % (ps_names, wmi_names))
|
||||
|
||||
def test_boot_time(self):
|
||||
wmi_os = wmi.WMI().Win32_OperatingSystem()
|
||||
wmi_btime_str = wmi_os[0].LastBootUpTime.split('.')[0]
|
||||
wmi_btime_dt = datetime.datetime.strptime(
|
||||
wmi_btime_str, "%Y%m%d%H%M%S")
|
||||
psutil_dt = datetime.datetime.fromtimestamp(psutil.boot_time())
|
||||
diff = abs((wmi_btime_dt - psutil_dt).total_seconds())
|
||||
self.assertLessEqual(diff, 5)
|
||||
|
||||
def test_boot_time_fluctuation(self):
|
||||
# https://github.com/giampaolo/psutil/issues/1007
|
||||
with mock.patch('psutil._pswindows.cext.boot_time', return_value=5):
|
||||
self.assertEqual(psutil.boot_time(), 5)
|
||||
with mock.patch('psutil._pswindows.cext.boot_time', return_value=4):
|
||||
self.assertEqual(psutil.boot_time(), 5)
|
||||
with mock.patch('psutil._pswindows.cext.boot_time', return_value=6):
|
||||
self.assertEqual(psutil.boot_time(), 5)
|
||||
with mock.patch('psutil._pswindows.cext.boot_time', return_value=333):
|
||||
self.assertEqual(psutil.boot_time(), 333)
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# sensors_battery()
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestSensorsBattery(WindowsTestCase):
|
||||
|
||||
def test_has_battery(self):
|
||||
if win32api.GetPwrCapabilities()['SystemBatteriesPresent']:
|
||||
self.assertIsNotNone(psutil.sensors_battery())
|
||||
else:
|
||||
self.assertIsNone(psutil.sensors_battery())
|
||||
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_percent(self):
|
||||
w = wmi.WMI()
|
||||
battery_wmi = w.query('select * from Win32_Battery')[0]
|
||||
battery_psutil = psutil.sensors_battery()
|
||||
self.assertAlmostEqual(
|
||||
battery_psutil.percent, battery_wmi.EstimatedChargeRemaining,
|
||||
delta=1)
|
||||
|
||||
@unittest.skipIf(not HAS_BATTERY, "no battery")
|
||||
def test_power_plugged(self):
|
||||
w = wmi.WMI()
|
||||
battery_wmi = w.query('select * from Win32_Battery')[0]
|
||||
battery_psutil = psutil.sensors_battery()
|
||||
# Status codes:
|
||||
# https://msdn.microsoft.com/en-us/library/aa394074(v=vs.85).aspx
|
||||
self.assertEqual(battery_psutil.power_plugged,
|
||||
battery_wmi.BatteryStatus == 2)
|
||||
|
||||
def test_emulate_no_battery(self):
|
||||
with mock.patch("psutil._pswindows.cext.sensors_battery",
|
||||
return_value=(0, 128, 0, 0)) as m:
|
||||
self.assertIsNone(psutil.sensors_battery())
|
||||
assert m.called
|
||||
|
||||
def test_emulate_power_connected(self):
|
||||
with mock.patch("psutil._pswindows.cext.sensors_battery",
|
||||
return_value=(1, 0, 0, 0)) as m:
|
||||
self.assertEqual(psutil.sensors_battery().secsleft,
|
||||
psutil.POWER_TIME_UNLIMITED)
|
||||
assert m.called
|
||||
|
||||
def test_emulate_power_charging(self):
|
||||
with mock.patch("psutil._pswindows.cext.sensors_battery",
|
||||
return_value=(0, 8, 0, 0)) as m:
|
||||
self.assertEqual(psutil.sensors_battery().secsleft,
|
||||
psutil.POWER_TIME_UNLIMITED)
|
||||
assert m.called
|
||||
|
||||
def test_emulate_secs_left_unknown(self):
|
||||
with mock.patch("psutil._pswindows.cext.sensors_battery",
|
||||
return_value=(0, 0, 0, -1)) as m:
|
||||
self.assertEqual(psutil.sensors_battery().secsleft,
|
||||
psutil.POWER_TIME_UNKNOWN)
|
||||
assert m.called
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# Process APIs
|
||||
# ===================================================================
|
||||
|
||||
|
||||
class TestProcess(WindowsTestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.pid = spawn_testproc().pid
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
terminate(cls.pid)
|
||||
|
||||
def test_issue_24(self):
|
||||
p = psutil.Process(0)
|
||||
self.assertRaises(psutil.AccessDenied, p.kill)
|
||||
|
||||
def test_special_pid(self):
|
||||
p = psutil.Process(4)
|
||||
self.assertEqual(p.name(), 'System')
|
||||
# use __str__ to access all common Process properties to check
|
||||
# that nothing strange happens
|
||||
str(p)
|
||||
p.username()
|
||||
self.assertTrue(p.create_time() >= 0.0)
|
||||
try:
|
||||
rss, vms = p.memory_info()[:2]
|
||||
except psutil.AccessDenied:
|
||||
# expected on Windows Vista and Windows 7
|
||||
if not platform.uname()[1] in ('vista', 'win-7', 'win7'):
|
||||
raise
|
||||
else:
|
||||
self.assertTrue(rss > 0)
|
||||
|
||||
def test_send_signal(self):
|
||||
p = psutil.Process(self.pid)
|
||||
self.assertRaises(ValueError, p.send_signal, signal.SIGINT)
|
||||
|
||||
def test_num_handles_increment(self):
|
||||
p = psutil.Process(os.getpid())
|
||||
before = p.num_handles()
|
||||
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
|
||||
win32con.FALSE, os.getpid())
|
||||
after = p.num_handles()
|
||||
self.assertEqual(after, before + 1)
|
||||
win32api.CloseHandle(handle)
|
||||
self.assertEqual(p.num_handles(), before)
|
||||
|
||||
def test_ctrl_signals(self):
|
||||
p = psutil.Process(self.spawn_testproc().pid)
|
||||
p.send_signal(signal.CTRL_C_EVENT)
|
||||
p.send_signal(signal.CTRL_BREAK_EVENT)
|
||||
p.kill()
|
||||
p.wait()
|
||||
self.assertRaises(psutil.NoSuchProcess,
|
||||
p.send_signal, signal.CTRL_C_EVENT)
|
||||
self.assertRaises(psutil.NoSuchProcess,
|
||||
p.send_signal, signal.CTRL_BREAK_EVENT)
|
||||
|
||||
def test_username(self):
|
||||
name = win32api.GetUserNameEx(win32con.NameSamCompatible)
|
||||
if name.endswith('$'):
|
||||
# When running as a service account (most likely to be
|
||||
# NetworkService), these user name calculations don't produce the
|
||||
# same result, causing the test to fail.
|
||||
raise unittest.SkipTest('running as service account')
|
||||
self.assertEqual(psutil.Process().username(), name)
|
||||
|
||||
def test_cmdline(self):
|
||||
sys_value = re.sub('[ ]+', ' ', win32api.GetCommandLine()).strip()
|
||||
psutil_value = ' '.join(psutil.Process().cmdline())
|
||||
if sys_value[0] == '"' != psutil_value[0]:
|
||||
# The PyWin32 command line may retain quotes around argv[0] if they
|
||||
# were used unnecessarily, while psutil will omit them. So remove
|
||||
# the first 2 quotes from sys_value if not in psutil_value.
|
||||
# A path to an executable will not contain quotes, so this is safe.
|
||||
sys_value = sys_value.replace('"', '', 2)
|
||||
self.assertEqual(sys_value, psutil_value)
|
||||
|
||||
# XXX - occasional failures
|
||||
|
||||
# def test_cpu_times(self):
|
||||
# handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
|
||||
# win32con.FALSE, os.getpid())
|
||||
# self.addCleanup(win32api.CloseHandle, handle)
|
||||
# sys_value = win32process.GetProcessTimes(handle)
|
||||
# psutil_value = psutil.Process().cpu_times()
|
||||
# self.assertAlmostEqual(
|
||||
# psutil_value.user, sys_value['UserTime'] / 10000000.0,
|
||||
# delta=0.2)
|
||||
# self.assertAlmostEqual(
|
||||
# psutil_value.user, sys_value['KernelTime'] / 10000000.0,
|
||||
# delta=0.2)
|
||||
|
||||
def test_nice(self):
|
||||
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
|
||||
win32con.FALSE, os.getpid())
|
||||
self.addCleanup(win32api.CloseHandle, handle)
|
||||
sys_value = win32process.GetPriorityClass(handle)
|
||||
psutil_value = psutil.Process().nice()
|
||||
self.assertEqual(psutil_value, sys_value)
|
||||
|
||||
def test_memory_info(self):
|
||||
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
|
||||
win32con.FALSE, self.pid)
|
||||
self.addCleanup(win32api.CloseHandle, handle)
|
||||
sys_value = win32process.GetProcessMemoryInfo(handle)
|
||||
psutil_value = psutil.Process(self.pid).memory_info()
|
||||
self.assertEqual(
|
||||
sys_value['PeakWorkingSetSize'], psutil_value.peak_wset)
|
||||
self.assertEqual(
|
||||
sys_value['WorkingSetSize'], psutil_value.wset)
|
||||
self.assertEqual(
|
||||
sys_value['QuotaPeakPagedPoolUsage'], psutil_value.peak_paged_pool)
|
||||
self.assertEqual(
|
||||
sys_value['QuotaPagedPoolUsage'], psutil_value.paged_pool)
|
||||
self.assertEqual(
|
||||
sys_value['QuotaPeakNonPagedPoolUsage'],
|
||||
psutil_value.peak_nonpaged_pool)
|
||||
self.assertEqual(
|
||||
sys_value['QuotaNonPagedPoolUsage'], psutil_value.nonpaged_pool)
|
||||
self.assertEqual(
|
||||
sys_value['PagefileUsage'], psutil_value.pagefile)
|
||||
self.assertEqual(
|
||||
sys_value['PeakPagefileUsage'], psutil_value.peak_pagefile)
|
||||
|
||||
self.assertEqual(psutil_value.rss, psutil_value.wset)
|
||||
self.assertEqual(psutil_value.vms, psutil_value.pagefile)
|
||||
|
||||
def test_wait(self):
|
||||
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
|
||||
win32con.FALSE, self.pid)
|
||||
self.addCleanup(win32api.CloseHandle, handle)
|
||||
p = psutil.Process(self.pid)
|
||||
p.terminate()
|
||||
psutil_value = p.wait()
|
||||
sys_value = win32process.GetExitCodeProcess(handle)
|
||||
self.assertEqual(psutil_value, sys_value)
|
||||
|
||||
def test_cpu_affinity(self):
|
||||
def from_bitmask(x):
|
||||
return [i for i in range(64) if (1 << i) & x]
|
||||
|
||||
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
|
||||
win32con.FALSE, self.pid)
|
||||
self.addCleanup(win32api.CloseHandle, handle)
|
||||
sys_value = from_bitmask(
|
||||
win32process.GetProcessAffinityMask(handle)[0])
|
||||
psutil_value = psutil.Process(self.pid).cpu_affinity()
|
||||
self.assertEqual(psutil_value, sys_value)
|
||||
|
||||
def test_io_counters(self):
|
||||
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
|
||||
win32con.FALSE, os.getpid())
|
||||
self.addCleanup(win32api.CloseHandle, handle)
|
||||
sys_value = win32process.GetProcessIoCounters(handle)
|
||||
psutil_value = psutil.Process().io_counters()
|
||||
self.assertEqual(
|
||||
psutil_value.read_count, sys_value['ReadOperationCount'])
|
||||
self.assertEqual(
|
||||
psutil_value.write_count, sys_value['WriteOperationCount'])
|
||||
self.assertEqual(
|
||||
psutil_value.read_bytes, sys_value['ReadTransferCount'])
|
||||
self.assertEqual(
|
||||
psutil_value.write_bytes, sys_value['WriteTransferCount'])
|
||||
self.assertEqual(
|
||||
psutil_value.other_count, sys_value['OtherOperationCount'])
|
||||
self.assertEqual(
|
||||
psutil_value.other_bytes, sys_value['OtherTransferCount'])
|
||||
|
||||
def test_num_handles(self):
|
||||
import ctypes
|
||||
import ctypes.wintypes
|
||||
PROCESS_QUERY_INFORMATION = 0x400
|
||||
handle = ctypes.windll.kernel32.OpenProcess(
|
||||
PROCESS_QUERY_INFORMATION, 0, self.pid)
|
||||
self.addCleanup(ctypes.windll.kernel32.CloseHandle, handle)
|
||||
|
||||
hndcnt = ctypes.wintypes.DWORD()
|
||||
ctypes.windll.kernel32.GetProcessHandleCount(
|
||||
handle, ctypes.byref(hndcnt))
|
||||
sys_value = hndcnt.value
|
||||
psutil_value = psutil.Process(self.pid).num_handles()
|
||||
self.assertEqual(psutil_value, sys_value)
|
||||
|
||||
def test_error_partial_copy(self):
|
||||
# https://github.com/giampaolo/psutil/issues/875
|
||||
exc = WindowsError()
|
||||
exc.winerror = 299
|
||||
with mock.patch("psutil._psplatform.cext.proc_cwd", side_effect=exc):
|
||||
with mock.patch("time.sleep") as m:
|
||||
p = psutil.Process()
|
||||
self.assertRaises(psutil.AccessDenied, p.cwd)
|
||||
self.assertGreaterEqual(m.call_count, 5)
|
||||
|
||||
def test_exe(self):
|
||||
# NtQuerySystemInformation succeeds if process is gone. Make sure
|
||||
# it raises NSP for a non existent pid.
|
||||
pid = psutil.pids()[-1] + 99999
|
||||
proc = psutil._psplatform.Process(pid)
|
||||
self.assertRaises(psutil.NoSuchProcess, proc.exe)
|
||||
|
||||
|
||||
class TestProcessWMI(WindowsTestCase):
|
||||
"""Compare Process API results with WMI."""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.pid = spawn_testproc().pid
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
terminate(cls.pid)
|
||||
|
||||
def test_name(self):
|
||||
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
p = psutil.Process(self.pid)
|
||||
self.assertEqual(p.name(), w.Caption)
|
||||
|
||||
# This fail on github because using virtualenv for test environment
|
||||
@unittest.skipIf(GITHUB_ACTIONS, "unreliable path on GITHUB_ACTIONS")
|
||||
def test_exe(self):
|
||||
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
p = psutil.Process(self.pid)
|
||||
# Note: wmi reports the exe as a lower case string.
|
||||
# Being Windows paths case-insensitive we ignore that.
|
||||
self.assertEqual(p.exe().lower(), w.ExecutablePath.lower())
|
||||
|
||||
def test_cmdline(self):
|
||||
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
p = psutil.Process(self.pid)
|
||||
self.assertEqual(' '.join(p.cmdline()),
|
||||
w.CommandLine.replace('"', ''))
|
||||
|
||||
def test_username(self):
|
||||
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
p = psutil.Process(self.pid)
|
||||
domain, _, username = w.GetOwner()
|
||||
username = "%s\\%s" % (domain, username)
|
||||
self.assertEqual(p.username(), username)
|
||||
|
||||
@retry_on_failure()
|
||||
def test_memory_rss(self):
|
||||
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
p = psutil.Process(self.pid)
|
||||
rss = p.memory_info().rss
|
||||
self.assertEqual(rss, int(w.WorkingSetSize))
|
||||
|
||||
@retry_on_failure()
|
||||
def test_memory_vms(self):
|
||||
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
p = psutil.Process(self.pid)
|
||||
vms = p.memory_info().vms
|
||||
# http://msdn.microsoft.com/en-us/library/aa394372(VS.85).aspx
|
||||
# ...claims that PageFileUsage is represented in Kilo
|
||||
# bytes but funnily enough on certain platforms bytes are
|
||||
# returned instead.
|
||||
wmi_usage = int(w.PageFileUsage)
|
||||
if (vms != wmi_usage) and (vms != wmi_usage * 1024):
|
||||
raise self.fail("wmi=%s, psutil=%s" % (wmi_usage, vms))
|
||||
|
||||
def test_create_time(self):
|
||||
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
|
||||
p = psutil.Process(self.pid)
|
||||
wmic_create = str(w.CreationDate.split('.')[0])
|
||||
psutil_create = time.strftime("%Y%m%d%H%M%S",
|
||||
time.localtime(p.create_time()))
|
||||
self.assertEqual(wmic_create, psutil_create)
|
||||
|
||||
|
||||
# ---
|
||||
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
class TestDualProcessImplementation(PsutilTestCase):
|
||||
"""
|
||||
Certain APIs on Windows have 2 internal implementations, one
|
||||
based on documented Windows APIs, another one based
|
||||
NtQuerySystemInformation() which gets called as fallback in
|
||||
case the first fails because of limited permission error.
|
||||
Here we test that the two methods return the exact same value,
|
||||
see:
|
||||
https://github.com/giampaolo/psutil/issues/304
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.pid = spawn_testproc().pid
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
terminate(cls.pid)
|
||||
|
||||
def test_memory_info(self):
|
||||
mem_1 = psutil.Process(self.pid).memory_info()
|
||||
with mock.patch("psutil._psplatform.cext.proc_memory_info",
|
||||
side_effect=OSError(errno.EPERM, "msg")) as fun:
|
||||
mem_2 = psutil.Process(self.pid).memory_info()
|
||||
self.assertEqual(len(mem_1), len(mem_2))
|
||||
for i in range(len(mem_1)):
|
||||
self.assertGreaterEqual(mem_1[i], 0)
|
||||
self.assertGreaterEqual(mem_2[i], 0)
|
||||
self.assertAlmostEqual(mem_1[i], mem_2[i], delta=512)
|
||||
assert fun.called
|
||||
|
||||
def test_create_time(self):
|
||||
ctime = psutil.Process(self.pid).create_time()
|
||||
with mock.patch("psutil._psplatform.cext.proc_times",
|
||||
side_effect=OSError(errno.EPERM, "msg")) as fun:
|
||||
self.assertEqual(psutil.Process(self.pid).create_time(), ctime)
|
||||
assert fun.called
|
||||
|
||||
def test_cpu_times(self):
|
||||
cpu_times_1 = psutil.Process(self.pid).cpu_times()
|
||||
with mock.patch("psutil._psplatform.cext.proc_times",
|
||||
side_effect=OSError(errno.EPERM, "msg")) as fun:
|
||||
cpu_times_2 = psutil.Process(self.pid).cpu_times()
|
||||
assert fun.called
|
||||
self.assertAlmostEqual(
|
||||
cpu_times_1.user, cpu_times_2.user, delta=0.01)
|
||||
self.assertAlmostEqual(
|
||||
cpu_times_1.system, cpu_times_2.system, delta=0.01)
|
||||
|
||||
def test_io_counters(self):
|
||||
io_counters_1 = psutil.Process(self.pid).io_counters()
|
||||
with mock.patch("psutil._psplatform.cext.proc_io_counters",
|
||||
side_effect=OSError(errno.EPERM, "msg")) as fun:
|
||||
io_counters_2 = psutil.Process(self.pid).io_counters()
|
||||
for i in range(len(io_counters_1)):
|
||||
self.assertAlmostEqual(
|
||||
io_counters_1[i], io_counters_2[i], delta=5)
|
||||
assert fun.called
|
||||
|
||||
def test_num_handles(self):
|
||||
num_handles = psutil.Process(self.pid).num_handles()
|
||||
with mock.patch("psutil._psplatform.cext.proc_num_handles",
|
||||
side_effect=OSError(errno.EPERM, "msg")) as fun:
|
||||
self.assertEqual(psutil.Process(self.pid).num_handles(),
|
||||
num_handles)
|
||||
assert fun.called
|
||||
|
||||
def test_cmdline(self):
|
||||
for pid in psutil.pids():
|
||||
try:
|
||||
a = cext.proc_cmdline(pid, use_peb=True)
|
||||
b = cext.proc_cmdline(pid, use_peb=False)
|
||||
except OSError as err:
|
||||
err = convert_oserror(err)
|
||||
if not isinstance(err, (psutil.AccessDenied,
|
||||
psutil.NoSuchProcess)):
|
||||
raise
|
||||
else:
|
||||
self.assertEqual(a, b)
|
||||
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
class RemoteProcessTestCase(PsutilTestCase):
|
||||
"""Certain functions require calling ReadProcessMemory.
|
||||
This trivially works when called on the current process.
|
||||
Check that this works on other processes, especially when they
|
||||
have a different bitness.
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def find_other_interpreter():
|
||||
# find a python interpreter that is of the opposite bitness from us
|
||||
code = "import sys; sys.stdout.write(str(sys.maxsize > 2**32))"
|
||||
|
||||
# XXX: a different and probably more stable approach might be to access
|
||||
# the registry but accessing 64 bit paths from a 32 bit process
|
||||
for filename in glob.glob(r"C:\Python*\python.exe"):
|
||||
proc = subprocess.Popen(args=[filename, "-c", code],
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT)
|
||||
output, _ = proc.communicate()
|
||||
proc.wait()
|
||||
if output == str(not IS_64BIT):
|
||||
return filename
|
||||
|
||||
test_args = ["-c", "import sys; sys.stdin.read()"]
|
||||
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
|
||||
other_python = self.find_other_interpreter()
|
||||
if other_python is None:
|
||||
raise unittest.SkipTest(
|
||||
"could not find interpreter with opposite bitness")
|
||||
if IS_64BIT:
|
||||
self.python64 = sys.executable
|
||||
self.python32 = other_python
|
||||
else:
|
||||
self.python64 = other_python
|
||||
self.python32 = sys.executable
|
||||
|
||||
env = os.environ.copy()
|
||||
env["THINK_OF_A_NUMBER"] = str(os.getpid())
|
||||
self.proc32 = self.spawn_testproc(
|
||||
[self.python32] + self.test_args,
|
||||
env=env,
|
||||
stdin=subprocess.PIPE)
|
||||
self.proc64 = self.spawn_testproc(
|
||||
[self.python64] + self.test_args,
|
||||
env=env,
|
||||
stdin=subprocess.PIPE)
|
||||
|
||||
def tearDown(self):
|
||||
super().tearDown()
|
||||
self.proc32.communicate()
|
||||
self.proc64.communicate()
|
||||
|
||||
def test_cmdline_32(self):
|
||||
p = psutil.Process(self.proc32.pid)
|
||||
self.assertEqual(len(p.cmdline()), 3)
|
||||
self.assertEqual(p.cmdline()[1:], self.test_args)
|
||||
|
||||
def test_cmdline_64(self):
|
||||
p = psutil.Process(self.proc64.pid)
|
||||
self.assertEqual(len(p.cmdline()), 3)
|
||||
self.assertEqual(p.cmdline()[1:], self.test_args)
|
||||
|
||||
def test_cwd_32(self):
|
||||
p = psutil.Process(self.proc32.pid)
|
||||
self.assertEqual(p.cwd(), os.getcwd())
|
||||
|
||||
def test_cwd_64(self):
|
||||
p = psutil.Process(self.proc64.pid)
|
||||
self.assertEqual(p.cwd(), os.getcwd())
|
||||
|
||||
def test_environ_32(self):
|
||||
p = psutil.Process(self.proc32.pid)
|
||||
e = p.environ()
|
||||
self.assertIn("THINK_OF_A_NUMBER", e)
|
||||
self.assertEqual(e["THINK_OF_A_NUMBER"], str(os.getpid()))
|
||||
|
||||
def test_environ_64(self):
|
||||
p = psutil.Process(self.proc64.pid)
|
||||
try:
|
||||
p.environ()
|
||||
except psutil.AccessDenied:
|
||||
pass
|
||||
|
||||
|
||||
# ===================================================================
|
||||
# Windows services
|
||||
# ===================================================================
|
||||
|
||||
|
||||
@unittest.skipIf(not WINDOWS, "WINDOWS only")
|
||||
class TestServices(PsutilTestCase):
|
||||
|
||||
def test_win_service_iter(self):
|
||||
valid_statuses = set([
|
||||
"running",
|
||||
"paused",
|
||||
"start",
|
||||
"pause",
|
||||
"continue",
|
||||
"stop",
|
||||
"stopped",
|
||||
])
|
||||
valid_start_types = set([
|
||||
"automatic",
|
||||
"manual",
|
||||
"disabled",
|
||||
])
|
||||
valid_statuses = set([
|
||||
"running",
|
||||
"paused",
|
||||
"start_pending",
|
||||
"pause_pending",
|
||||
"continue_pending",
|
||||
"stop_pending",
|
||||
"stopped"
|
||||
])
|
||||
for serv in psutil.win_service_iter():
|
||||
data = serv.as_dict()
|
||||
self.assertIsInstance(data['name'], str)
|
||||
self.assertNotEqual(data['name'].strip(), "")
|
||||
self.assertIsInstance(data['display_name'], str)
|
||||
self.assertIsInstance(data['username'], str)
|
||||
self.assertIn(data['status'], valid_statuses)
|
||||
if data['pid'] is not None:
|
||||
psutil.Process(data['pid'])
|
||||
self.assertIsInstance(data['binpath'], str)
|
||||
self.assertIsInstance(data['username'], str)
|
||||
self.assertIsInstance(data['start_type'], str)
|
||||
self.assertIn(data['start_type'], valid_start_types)
|
||||
self.assertIn(data['status'], valid_statuses)
|
||||
self.assertIsInstance(data['description'], str)
|
||||
pid = serv.pid()
|
||||
if pid is not None:
|
||||
p = psutil.Process(pid)
|
||||
self.assertTrue(p.is_running())
|
||||
# win_service_get
|
||||
s = psutil.win_service_get(serv.name())
|
||||
# test __eq__
|
||||
self.assertEqual(serv, s)
|
||||
|
||||
def test_win_service_get(self):
|
||||
ERROR_SERVICE_DOES_NOT_EXIST = \
|
||||
psutil._psplatform.cext.ERROR_SERVICE_DOES_NOT_EXIST
|
||||
ERROR_ACCESS_DENIED = psutil._psplatform.cext.ERROR_ACCESS_DENIED
|
||||
|
||||
name = next(psutil.win_service_iter()).name()
|
||||
with self.assertRaises(psutil.NoSuchProcess) as cm:
|
||||
psutil.win_service_get(name + '???')
|
||||
self.assertEqual(cm.exception.name, name + '???')
|
||||
|
||||
# test NoSuchProcess
|
||||
service = psutil.win_service_get(name)
|
||||
if PY3:
|
||||
args = (0, "msg", 0, ERROR_SERVICE_DOES_NOT_EXIST)
|
||||
else:
|
||||
args = (ERROR_SERVICE_DOES_NOT_EXIST, "msg")
|
||||
exc = WindowsError(*args)
|
||||
with mock.patch("psutil._psplatform.cext.winservice_query_status",
|
||||
side_effect=exc):
|
||||
self.assertRaises(psutil.NoSuchProcess, service.status)
|
||||
with mock.patch("psutil._psplatform.cext.winservice_query_config",
|
||||
side_effect=exc):
|
||||
self.assertRaises(psutil.NoSuchProcess, service.username)
|
||||
|
||||
# test AccessDenied
|
||||
if PY3:
|
||||
args = (0, "msg", 0, ERROR_ACCESS_DENIED)
|
||||
else:
|
||||
args = (ERROR_ACCESS_DENIED, "msg")
|
||||
exc = WindowsError(*args)
|
||||
with mock.patch("psutil._psplatform.cext.winservice_query_status",
|
||||
side_effect=exc):
|
||||
self.assertRaises(psutil.AccessDenied, service.status)
|
||||
with mock.patch("psutil._psplatform.cext.winservice_query_config",
|
||||
side_effect=exc):
|
||||
self.assertRaises(psutil.AccessDenied, service.username)
|
||||
|
||||
# test __str__ and __repr__
|
||||
self.assertIn(service.name(), str(service))
|
||||
self.assertIn(service.display_name(), str(service))
|
||||
self.assertIn(service.name(), repr(service))
|
||||
self.assertIn(service.display_name(), repr(service))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from psutil.tests.runner import run_from_name
|
||||
run_from_name(__file__)
|
Loading…
Reference in New Issue