Documentation

Index

Constants

View Source
const (
	Running = "running"
	Sleep   = "sleep"
	Stop    = "stop"
	Idle    = "idle"
	Zombie  = "zombie"
	Wait    = "wait"
	Lock    = "lock"
)

    Process status

    View Source
    const (
    	RLIMIT_CPU        int32 = 0
    	RLIMIT_FSIZE      int32 = 1
    	RLIMIT_DATA       int32 = 2
    	RLIMIT_STACK      int32 = 3
    	RLIMIT_CORE       int32 = 4
    	RLIMIT_RSS        int32 = 5
    	RLIMIT_NPROC      int32 = 6
    	RLIMIT_NOFILE     int32 = 7
    	RLIMIT_MEMLOCK    int32 = 8
    	RLIMIT_AS         int32 = 9
    	RLIMIT_LOCKS      int32 = 10
    	RLIMIT_SIGPENDING int32 = 11
    	RLIMIT_MSGQUEUE   int32 = 12
    	RLIMIT_NICE       int32 = 13
    	RLIMIT_RTPRIO     int32 = 14
    	RLIMIT_RTTIME     int32 = 15
    )

      Resource limit constants are from /usr/include/x86_64-linux-gnu/bits/resource.h from libc6-dev package in Ubuntu 16.10

      Variables

      View Source
      var (
      	ErrorNoChildren        = errors.New("process does not have children")
      	ErrorProcessNotRunning = errors.New("process does not exist")
      )

      Functions

      func PidExists

      func PidExists(pid int32) (bool, error)

      func PidExistsWithContext

      func PidExistsWithContext(ctx context.Context, pid int32) (bool, error)

      func Pids

      func Pids() ([]int32, error)

        Pids returns a slice of process ID list which are running now.

        func PidsWithContext

        func PidsWithContext(ctx context.Context) ([]int32, error)

        Types

        type IOCountersStat

        type IOCountersStat struct {
        	ReadCount  uint64 `json:"readCount"`
        	WriteCount uint64 `json:"writeCount"`
        	ReadBytes  uint64 `json:"readBytes"`
        	WriteBytes uint64 `json:"writeBytes"`
        }

        func (IOCountersStat) String

        func (i IOCountersStat) String() string

        type MemoryInfoExStat

        type MemoryInfoExStat struct {
        	RSS    uint64 `json:"rss"`    // bytes
        	VMS    uint64 `json:"vms"`    // bytes
        	Shared uint64 `json:"shared"` // bytes
        	Text   uint64 `json:"text"`   // bytes
        	Lib    uint64 `json:"lib"`    // bytes
        	Data   uint64 `json:"data"`   // bytes
        	Dirty  uint64 `json:"dirty"`  // bytes
        }

          MemoryInfoExStat is different between OSes

          func (MemoryInfoExStat) String

          func (m MemoryInfoExStat) String() string

          type MemoryInfoStat

          type MemoryInfoStat struct {
          	RSS    uint64 `json:"rss"`    // bytes
          	VMS    uint64 `json:"vms"`    // bytes
          	HWM    uint64 `json:"hwm"`    // bytes
          	Data   uint64 `json:"data"`   // bytes
          	Stack  uint64 `json:"stack"`  // bytes
          	Locked uint64 `json:"locked"` // bytes
          	Swap   uint64 `json:"swap"`   // bytes
          }

          func (MemoryInfoStat) String

          func (m MemoryInfoStat) String() string

          type MemoryMapsStat

          type MemoryMapsStat struct {
          	Path         string `json:"path"`
          	Rss          uint64 `json:"rss"`
          	Size         uint64 `json:"size"`
          	Pss          uint64 `json:"pss"`
          	SharedClean  uint64 `json:"sharedClean"`
          	SharedDirty  uint64 `json:"sharedDirty"`
          	PrivateClean uint64 `json:"privateClean"`
          	PrivateDirty uint64 `json:"privateDirty"`
          	Referenced   uint64 `json:"referenced"`
          	Anonymous    uint64 `json:"anonymous"`
          	Swap         uint64 `json:"swap"`
          }

          func (MemoryMapsStat) String

          func (m MemoryMapsStat) String() string

            String returns JSON value of the process.

            type NumCtxSwitchesStat

            type NumCtxSwitchesStat struct {
            	Voluntary   int64 `json:"voluntary"`
            	Involuntary int64 `json:"involuntary"`
            }

            func (NumCtxSwitchesStat) String

            func (p NumCtxSwitchesStat) String() string

            type OpenFilesStat

            type OpenFilesStat struct {
            	Path string `json:"path"`
            	Fd   uint64 `json:"fd"`
            }

            func (OpenFilesStat) String

            func (o OpenFilesStat) String() string

            type PageFaultsStat

            type PageFaultsStat struct {
            	MinorFaults      uint64 `json:"minorFaults"`
            	MajorFaults      uint64 `json:"majorFaults"`
            	ChildMinorFaults uint64 `json:"childMinorFaults"`
            	ChildMajorFaults uint64 `json:"childMajorFaults"`
            }

            type Process

            type Process struct {
            	Pid int32 `json:"pid"`
            	// contains filtered or unexported fields
            }

            func NewProcess

            func NewProcess(pid int32) (*Process, error)

              NewProcess creates a new Process instance, it only stores the pid and checks that the process exists. Other method on Process can be used to get more information about the process. An error will be returned if the process does not exist.

              func NewProcessWithContext

              func NewProcessWithContext(ctx context.Context, pid int32) (*Process, error)

              func Processes

              func Processes() ([]*Process, error)

                Processes returns a slice of pointers to Process structs for all currently running processes.

                func ProcessesWithContext

                func ProcessesWithContext(ctx context.Context) ([]*Process, error)

                func (*Process) Background

                func (p *Process) Background() (bool, error)

                  Background returns true if the process is in background, false otherwise.

                  func (*Process) BackgroundWithContext

                  func (p *Process) BackgroundWithContext(ctx context.Context) (bool, error)

                  func (*Process) CPUAffinity

                  func (p *Process) CPUAffinity() ([]int32, error)

                    CPUAffinity returns CPU affinity of the process.

                    func (*Process) CPUAffinityWithContext

                    func (p *Process) CPUAffinityWithContext(ctx context.Context) ([]int32, error)

                    func (*Process) CPUPercent

                    func (p *Process) CPUPercent() (float64, error)

                      CPU_Percent returns how many percent of the CPU time this process uses

                      func (*Process) CPUPercentWithContext

                      func (p *Process) CPUPercentWithContext(ctx context.Context) (float64, error)

                      func (*Process) Children

                      func (p *Process) Children() ([]*Process, error)

                        Children returns the children of the process represented as a slice of pointers to Process type.

                        func (*Process) ChildrenWithContext

                        func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error)

                        func (*Process) Cmdline

                        func (p *Process) Cmdline() (string, error)

                          Cmdline returns the command line arguments of the process as a string with each argument separated by 0x20 ascii character.

                          func (*Process) CmdlineSlice

                          func (p *Process) CmdlineSlice() ([]string, error)

                            CmdlineSlice returns the command line arguments of the process as a slice with each element being an argument.

                            func (*Process) CmdlineSliceWithContext

                            func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error)

                            func (*Process) CmdlineWithContext

                            func (p *Process) CmdlineWithContext(ctx context.Context) (string, error)

                            func (*Process) Connections

                            func (p *Process) Connections() ([]net.ConnectionStat, error)

                              Connections returns a slice of net.ConnectionStat used by the process. This returns all kind of the connection. This means TCP, UDP or UNIX.

                              func (*Process) ConnectionsMax

                              func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error)

                                Connections returns a slice of net.ConnectionStat used by the process at most `max`.

                                func (*Process) ConnectionsMaxWithContext

                                func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error)

                                func (*Process) ConnectionsWithContext

                                func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionStat, error)

                                func (*Process) CreateTime

                                func (p *Process) CreateTime() (int64, error)

                                  CreateTime returns created time of the process in milliseconds since the epoch, in UTC.

                                  func (*Process) CreateTimeWithContext

                                  func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error)

                                  func (*Process) Cwd

                                  func (p *Process) Cwd() (string, error)

                                    Cwd returns current working directory of the process.

                                    func (*Process) CwdWithContext

                                    func (p *Process) CwdWithContext(ctx context.Context) (string, error)

                                    func (*Process) Exe

                                    func (p *Process) Exe() (string, error)

                                      Exe returns executable path of the process.

                                      func (*Process) ExeWithContext

                                      func (p *Process) ExeWithContext(ctx context.Context) (string, error)

                                      func (*Process) Foreground

                                      func (p *Process) Foreground() (bool, error)

                                        Foreground returns true if the process is in foreground, false otherwise.

                                        func (*Process) ForegroundWithContext

                                        func (p *Process) ForegroundWithContext(ctx context.Context) (bool, error)

                                        func (*Process) Gids

                                        func (p *Process) Gids() ([]int32, error)

                                          Gids returns group ids of the process as a slice of the int

                                          func (*Process) GidsWithContext

                                          func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error)

                                          func (*Process) Groups

                                          func (p *Process) Groups() ([]int32, error)

                                            Groups returns all group IDs(include supplementary groups) of the process as a slice of the int

                                            func (*Process) GroupsWithContext

                                            func (p *Process) GroupsWithContext(ctx context.Context) ([]int32, error)

                                            func (*Process) IOCounters

                                            func (p *Process) IOCounters() (*IOCountersStat, error)

                                              IOCounters returns IO Counters.

                                              func (*Process) IOCountersWithContext

                                              func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, error)

                                              func (*Process) IOnice

                                              func (p *Process) IOnice() (int32, error)

                                                IOnice returns process I/O nice value (priority).

                                                func (*Process) IOniceWithContext

                                                func (p *Process) IOniceWithContext(ctx context.Context) (int32, error)

                                                func (*Process) IsRunning

                                                func (p *Process) IsRunning() (bool, error)

                                                  IsRunning returns whether the process is still running or not.

                                                  func (*Process) IsRunningWithContext

                                                  func (p *Process) IsRunningWithContext(ctx context.Context) (bool, error)

                                                  func (*Process) Kill

                                                  func (p *Process) Kill() error

                                                    Kill sends SIGKILL to the process.

                                                    func (*Process) KillWithContext

                                                    func (p *Process) KillWithContext(ctx context.Context) error

                                                    func (*Process) MemoryInfo

                                                    func (p *Process) MemoryInfo() (*MemoryInfoStat, error)

                                                      MemoryInfo returns generic process memory information, such as RSS and VMS.

                                                      func (*Process) MemoryInfoEx

                                                      func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error)

                                                        MemoryInfoEx returns platform-specific process memory information.

                                                        func (*Process) MemoryInfoExWithContext

                                                        func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error)

                                                        func (*Process) MemoryInfoWithContext

                                                        func (p *Process) MemoryInfoWithContext(ctx context.Context) (*MemoryInfoStat, error)

                                                        func (*Process) MemoryMaps

                                                        func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error)

                                                          MemoryMaps get memory maps from /proc/(pid)/smaps

                                                          func (*Process) MemoryMapsWithContext

                                                          func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]MemoryMapsStat, error)

                                                          func (*Process) MemoryPercent

                                                          func (p *Process) MemoryPercent() (float32, error)

                                                            MemoryPercent returns how many percent of the total RAM this process uses

                                                            func (*Process) MemoryPercentWithContext

                                                            func (p *Process) MemoryPercentWithContext(ctx context.Context) (float32, error)

                                                            func (*Process) Name

                                                            func (p *Process) Name() (string, error)

                                                              Name returns name of the process.

                                                              func (*Process) NameWithContext

                                                              func (p *Process) NameWithContext(ctx context.Context) (string, error)

                                                              func (*Process) Nice

                                                              func (p *Process) Nice() (int32, error)

                                                                Nice returns a nice value (priority).

                                                                func (*Process) NiceWithContext

                                                                func (p *Process) NiceWithContext(ctx context.Context) (int32, error)

                                                                func (*Process) NumCtxSwitches

                                                                func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error)

                                                                  NumCtxSwitches returns the number of the context switches of the process.

                                                                  func (*Process) NumCtxSwitchesWithContext

                                                                  func (p *Process) NumCtxSwitchesWithContext(ctx context.Context) (*NumCtxSwitchesStat, error)

                                                                  func (*Process) NumFDs

                                                                  func (p *Process) NumFDs() (int32, error)

                                                                    NumFDs returns the number of File Descriptors used by the process.

                                                                    func (*Process) NumFDsWithContext

                                                                    func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error)

                                                                    func (*Process) NumThreads

                                                                    func (p *Process) NumThreads() (int32, error)

                                                                      NumThreads returns the number of threads used by the process.

                                                                      func (*Process) NumThreadsWithContext

                                                                      func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error)

                                                                      func (*Process) OpenFiles

                                                                      func (p *Process) OpenFiles() ([]OpenFilesStat, error)

                                                                        OpenFiles returns a slice of OpenFilesStat opend by the process. OpenFilesStat includes a file path and file descriptor.

                                                                        func (*Process) OpenFilesWithContext

                                                                        func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, error)

                                                                        func (*Process) PageFaults

                                                                        func (p *Process) PageFaults() (*PageFaultsStat, error)

                                                                          PageFaultsInfo returns the process's page fault counters.

                                                                          func (*Process) PageFaultsWithContext

                                                                          func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error)

                                                                          func (*Process) Parent

                                                                          func (p *Process) Parent() (*Process, error)

                                                                            Parent returns parent Process of the process.

                                                                            func (*Process) ParentWithContext

                                                                            func (p *Process) ParentWithContext(ctx context.Context) (*Process, error)

                                                                            func (*Process) Percent

                                                                            func (p *Process) Percent(interval time.Duration) (float64, error)

                                                                              If interval is 0, return difference from last call(non-blocking). If interval > 0, wait interval sec and return diffrence between start and end.

                                                                              func (*Process) PercentWithContext

                                                                              func (p *Process) PercentWithContext(ctx context.Context, interval time.Duration) (float64, error)

                                                                              func (*Process) Ppid

                                                                              func (p *Process) Ppid() (int32, error)

                                                                                Ppid returns Parent Process ID of the process.

                                                                                func (*Process) PpidWithContext

                                                                                func (p *Process) PpidWithContext(ctx context.Context) (int32, error)

                                                                                func (*Process) Resume

                                                                                func (p *Process) Resume() error

                                                                                  Resume sends SIGCONT to the process.

                                                                                  func (*Process) ResumeWithContext

                                                                                  func (p *Process) ResumeWithContext(ctx context.Context) error

                                                                                  func (*Process) Rlimit

                                                                                  func (p *Process) Rlimit() ([]RlimitStat, error)

                                                                                    Rlimit returns Resource Limits.

                                                                                    func (*Process) RlimitUsage

                                                                                    func (p *Process) RlimitUsage(gatherUsed bool) ([]RlimitStat, error)

                                                                                      RlimitUsage returns Resource Limits. If gatherUsed is true, the currently used value will be gathered and added to the resulting RlimitStat.

                                                                                      func (*Process) RlimitUsageWithContext

                                                                                      func (p *Process) RlimitUsageWithContext(ctx context.Context, gatherUsed bool) ([]RlimitStat, error)

                                                                                      func (*Process) RlimitWithContext

                                                                                      func (p *Process) RlimitWithContext(ctx context.Context) ([]RlimitStat, error)

                                                                                      func (*Process) SendSignal

                                                                                      func (p *Process) SendSignal(sig syscall.Signal) error

                                                                                        SendSignal sends a unix.Signal to the process.

                                                                                        func (*Process) SendSignalWithContext

                                                                                        func (p *Process) SendSignalWithContext(ctx context.Context, sig syscall.Signal) error

                                                                                        func (*Process) Status

                                                                                        func (p *Process) Status() ([]string, error)

                                                                                          Status returns the process status. Return value could be one of these. R: Running S: Sleep T: Stop I: Idle Z: Zombie W: Wait L: Lock The character is same within all supported platforms.

                                                                                          func (*Process) StatusWithContext

                                                                                          func (p *Process) StatusWithContext(ctx context.Context) ([]string, error)

                                                                                          func (Process) String

                                                                                          func (p Process) String() string

                                                                                          func (*Process) Suspend

                                                                                          func (p *Process) Suspend() error

                                                                                            Suspend sends SIGSTOP to the process.

                                                                                            func (*Process) SuspendWithContext

                                                                                            func (p *Process) SuspendWithContext(ctx context.Context) error

                                                                                            func (*Process) Terminal

                                                                                            func (p *Process) Terminal() (string, error)

                                                                                              Terminal returns a terminal which is associated with the process.

                                                                                              func (*Process) TerminalWithContext

                                                                                              func (p *Process) TerminalWithContext(ctx context.Context) (string, error)

                                                                                              func (*Process) Terminate

                                                                                              func (p *Process) Terminate() error

                                                                                                Terminate sends SIGTERM to the process.

                                                                                                func (*Process) TerminateWithContext

                                                                                                func (p *Process) TerminateWithContext(ctx context.Context) error

                                                                                                func (*Process) Tgid

                                                                                                func (p *Process) Tgid() (int32, error)

                                                                                                  Tgid returns thread group id of the process.

                                                                                                  func (*Process) TgidWithContext

                                                                                                  func (p *Process) TgidWithContext(ctx context.Context) (int32, error)

                                                                                                  func (*Process) Threads

                                                                                                  func (p *Process) Threads() (map[int32]*cpu.TimesStat, error)

                                                                                                  func (*Process) ThreadsWithContext

                                                                                                  func (p *Process) ThreadsWithContext(ctx context.Context) (map[int32]*cpu.TimesStat, error)

                                                                                                  func (*Process) Times

                                                                                                  func (p *Process) Times() (*cpu.TimesStat, error)

                                                                                                    Times returns CPU times of the process.

                                                                                                    func (*Process) TimesWithContext

                                                                                                    func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error)

                                                                                                    func (*Process) Uids

                                                                                                    func (p *Process) Uids() ([]int32, error)

                                                                                                      Uids returns user ids of the process as a slice of the int

                                                                                                      func (*Process) UidsWithContext

                                                                                                      func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error)

                                                                                                      func (*Process) Username

                                                                                                      func (p *Process) Username() (string, error)

                                                                                                        Username returns a username of the process.

                                                                                                        func (*Process) UsernameWithContext

                                                                                                        func (p *Process) UsernameWithContext(ctx context.Context) (string, error)

                                                                                                        type RlimitStat

                                                                                                        type RlimitStat struct {
                                                                                                        	Resource int32  `json:"resource"`
                                                                                                        	Soft     uint64 `json:"soft"`
                                                                                                        	Hard     uint64 `json:"hard"`
                                                                                                        	Used     uint64 `json:"used"`
                                                                                                        }

                                                                                                        func (RlimitStat) String

                                                                                                        func (r RlimitStat) String() string

                                                                                                        type SignalInfoStat

                                                                                                        type SignalInfoStat struct {
                                                                                                        	PendingProcess uint64 `json:"pending_process"`
                                                                                                        	PendingThread  uint64 `json:"pending_thread"`
                                                                                                        	Blocked        uint64 `json:"blocked"`
                                                                                                        	Ignored        uint64 `json:"ignored"`
                                                                                                        	Caught         uint64 `json:"caught"`
                                                                                                        }