text: # 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)
  