diff env/lib/python3.7/site-packages/psutil/_psaix.py @ 5:9b1c78e6ba9c draft default tip

"planemo upload commit 6c0a8142489327ece472c84e558c47da711a9142"

--- a/env/lib/python3.7/site-packages/psutil/_psaix.py	Thu May 14 16:47:39 2020 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,550 +0,0 @@
-# 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 AccessDenied
-from ._common import conn_to_ntuple
-from ._common import get_procfs_path
-from ._common import memoize_when_activated
-from ._common import NIC_DUPLEX_FULL
-from ._common import NIC_DUPLEX_HALF
-from ._common import NIC_DUPLEX_UNKNOWN
-from ._common import NoSuchProcess
-from ._common import usage_percent
-from ._common import ZombieProcess
-from ._compat import FileNotFoundError
-from ._compat import PermissionError
-from ._compat import ProcessLookupError
-from ._compat import PY3
-
-
-__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 = os.sysconf('SC_PAGE_SIZE')
-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_physical():
-    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
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
-        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:
-        isup, mtu = cext.net_if_stats(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)
-
-        duplex = duplex_map.get(duplex, NIC_DUPLEX_UNKNOWN)
-        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(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):
-        cpu_times = cext.proc_cpu_times(self.pid, self._procfs_path)
-        return _common.pcputimes(*cpu_times)
-
-    @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 None
-
-    @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)