# salt.modules.ps

A salt interface to psutil, a system and process library. See http://code.google.com/p/psutil.

depends: | psutil Python module

`salt.modules.ps.` `boot_time`()

  Return the boot time in number of seconds since the epoch began.

  CLI Example:

      salt '*' ps.boot_time

`salt.modules.ps.` `cached_physical_memory`()

  Return the amount cached memory.

  CLI Example:

      salt '*' ps.cached_physical_memory

`salt.modules.ps.` `cpu_percent`(interval=0.1, per_cpu=False)

  Return the percent of time the CPU is busy.

  interval
    the number of seconds to sample CPU usage over
  per_cpu
    if True return an array of CPU percent busy for each CPU, otherwise aggregate all percents into one number

  CLI Example:

      salt '*' ps.cpu_percent

`salt.modules.ps.` `cpu_times`(per_cpu=False)

  Return the percent of time the CPU spends in each state, e.g. user, system, idle, nice, iowait, irq, softirq.

  per_cpu
    if True return an array of percents for each CPU, otherwise aggregate all percents into one number

  CLI Example:

      salt '*' ps.cpu_times

`salt.modules.ps.` `disk_io_counters`()

  Return disk I/O statisitics.

  CLI Example:

      salt '*' ps.disk_io_counters

`salt.modules.ps.` `disk_partition_usage`(all=False)

  Return a list of disk partitions plus the mount point, filesystem and usage statistics.

  CLI Example:

      salt '*' ps.disk_partition_usage

`salt.modules.ps.` `disk_partitions`(all=False)

  Return a list of disk partitions and their device, mount point, and filesystem type.

  all
    if set to False, only return local, physical partitions (hard disk, USB, CD/DVD partitions). If True, return all filesystems.

  CLI Example:

      salt '*' ps.disk_partitions

`salt.modules.ps.` `disk_usage`(path)

  Given a path, return a dict listing the total available space as well as the free space, and used space.

  CLI Example:

      salt '*' ps.disk_usage /home

`salt.modules.ps.` `get_pid_list`()

  Return a list of process ids (PIDs) for all running processes.

  CLI Example:

      salt '*' ps.get_pid_list

`salt.modules.ps.` `kill_pid`(pid, signal=15)

  Kill a proccess by PID.

      salt 'minion' ps.kill_pid pid [signal=signal_number]

  pid
    PID of process to kill.
  signal
    Signal to send to the process. See manpage entry for kill for possible values. Default: 15 (SIGTERM).

  Example:

  Send SIGKILL to process with PID 2000:

      salt 'minion' ps.kill_pid 2000 signal=9

`salt.modules.ps.` `network_io_counters`()

  Return network I/O statisitics.

  CLI Example:

      salt '*' ps.network_io_counters

`salt.modules.ps.` `num_cpus`()

  Return the number of CPUs.

  CLI Example:

      salt '*' ps.num_cpus

`salt.modules.ps.` `pgrep`(pattern, user=None, full=False)

  Return the pids for processes matching a pattern.

  If full is true, the full command line is searched for a match, otherwise only the name of the command is searched.

      salt '*' ps.pgrep pattern [user=username] [full=(true|false)]

  pattern
    Pattern to search for in the process list.
  user
    Limit matches to the given username. Default: All users.
  full
    A boolean value indicating whether only the name of the command or the full command line should be matched against the pattern.

  Examples:

  Find all httpd processes on all 'www' minions:

      salt 'www.*' httpd

  Find all bash processes owned by user 'tom':

      salt '*' bash user=tom

`salt.modules.ps.` `physical_memory_buffers`()

  Return the amount of physical memory buffers.

  CLI Example:

      salt '*' ps.physical_memory_buffers

`salt.modules.ps.` `physical_memory_usage`()

  Return a dict that describes free and available physical memory.

  CLI Examples:

      salt '*' ps.physical_memory_usage

`salt.modules.ps.` `pkill`(pattern, user=None, signal=15, full=False)

  Kill processes matching a pattern.

      salt '*' ps.pkill pattern [user=username] [signal=signal_number] \
              [full=(true|false)]

  pattern
    Pattern to search for in the process list.
  user
    Limit matches to the given username. Default: All users.
  signal
    Signal to send to the process(es). See manpage entry for kill for possible values. Default: 15 (SIGTERM).
  full
    A boolean value indicating whether only the name of the command or the full command line should be matched against the pattern.

  Examples:

  Send SIGHUP to all httpd processes on all 'www' minions:

      salt 'www.*' httpd signal=1

  Send SIGKILL to all bash processes owned by user 'tom':

      salt '*' bash signal=9 user=tom

`salt.modules.ps.` `top`(num_processes=5, interval=3)

  Return a list of top CPU consuming processes during the interval. num_processes = return the top N CPU consuming processes interval = the number of seconds to sample CPU usage over

  CLI Examples:

      salt '*' ps.top

      salt '*' ps.top 5 10

`salt.modules.ps.` `total_physical_memory`()

  Return the total number of bytes of physical memory.

  CLI Example:

      salt '*' ps.total_physical_memory

`salt.modules.ps.` `virtual_memory_usage`()

  Return a dict that describes free and available memory, both physical and virtual.

  CLI Example:

      salt '*' ps.virtual_memory_usage

Current Salt release: 0.17.1

#### Previous topic

salt.modules.powerpath

#### Next topic

salt.modules.publish

### Quick search

Enter search terms or a module, class or function name.

### Upcoming SaltStack Events

My conferences on Lanyrd