Hey there.

Is it possible to do releases or tags here?

Love, someone having to maintain a Gopkg.toml

Hi,

The loop in https://github.com/mitchellh/go-ps/blob/master/process_windows.go#L112 can return false for (A) successfully reaching the end of the list, or (B) some other error.

As per https://docs.microsoft.com/en-us/windows/win32/api/tlhelp32/nf-tlhelp32-process32nextw we must check GetLastError() for ERROR_NO_MORE_FILES after exiting this loop.

I encountered this problem today, on a PC under memory pressure, where this function returned a truncated process list.

I have a need to show the complete list of processes, so that Go code running inside Windows Subsystem for Linux reports not only the Linux processes, but the native Windows processes as well. Could we please expand the list?

For example, detect when the environment is WSL. Then run /mnt/c/Windows/System32/tasklist.exe and parse the results.

If a process's executable is deleted, calling Path() will return a &os.PathError{}.
Should just return the path whether or not the executable is deleted or replaced.

// FindProcess looks up a single process by pid.
func FindProcess(pid int) (Process, error) {
	return findProcess(pid)
}

If the process cannot be found, it is better to return an error

Proposal:

// -- compile-command: "go build main.go" --
// https://golang.org/pkg/errors/#pkg-index
package main

import (
"errors"
"fmt"
"os"
"github.com/mitchellh/go-ps"
"github.com/pborman/getopt"
)

const ()

func PS(){
ps, _ := ps.Processes()
fmt.Println(ps[0].Executable())
for pp, _ := range(ps){
fmt.Printf("%d %s\n", ps[pp].Pid(),ps[pp].Executable())
}
}

func FindProcess(key string) (int, string, error) {
pname := ""
pid := 0
err := errors.New("not found")
ps, _ := ps.Processes()
for i, _ := range ps {
if ps[i].Executable() == key {
pid = ps[i].Pid()
pname = ps[i].Executable()
err = nil
break
}
}
return pid, pname, err
} // FindProcess( key string ) ( int, string, error )

func main() {
// exit code
rc := 0
// values from command line
optHelp := getopt.BoolLong("help", 0, "Help")
getopt.Parse()
if *optHelp {
getopt.Usage()
os.Exit(rc)
}
if pid, s, err := FindProcess("emacs"); err == nil {
fmt.Printf ("Pid:%d, Pname:%s\n", pid, s)
}

fmt.Println("")
os.Exit(rc)

}

There are scenarios where people want to look at the actual command of a process, especially when there are multiple processes with same binary but using different parameters

Hi,

First, thank for you tool!
I would like to known if possible to implemente feature to obtains full path of a process.
For linux is just read "/proc/PID/exe"...
On windows, maybe like https://github.com/kardianos/osext/blob/master/osext_windows.go ...

Thanks.
Lionel

Linux have process name in cmdline or comm, so in my case is useful to get process name to match some pattern

Process names might be truncated on darwin, linux.

This fork here which has the full process executable path, uses filepath.Base(..) to get the full name:
https://github.com/keybase/go-ps

when using
go get github.com/mitchellh/go-ps,
the package is placed in
~/go/src/github.com/mitchellh/go-ps
however the package is ps.
I fixed it locally by changing the directory to gops and modifying the package in the each file.

Hi,

I am happy to report that process querying is working well with go-ps.

Could we add a portable Terminate() function to the process interface? This can help developers to cleanup after stuck processes in a platform independent way.

Hi @mitchellh ,

Thanks for such a nice Library.Before this plugin i was trying for the following approaches.

1)Calling the C code which does the Command based logic in getting the top process.
2)Execute a os command and fetch the values and iterate them

Here is the sample output for 5 top process running on my pc
vagrant@vagrant-ubuntu-trusty-64:~/$ ps aux | awk '{print $2, $4, $11}' | sort -k2rn | head -n 5|awk '{print $1}'
1812
1847
925
2232
2286

Is there a possibility that i can do this through the library.I see there are two important functions available where one gets all the porcess pid's running on the machine and the other gets the information of a specific PID.

I was thinking if there is a way or a logic if i can get the top five process running from the library as a function.

Thanks again for the library
Vamsi KGR

I have handmade linux implementation that for specific pid returns it child pids.
Also i'm using serach by process name to get all pids for this process name mask.
I can create pr for this (start from linux and may be freebsd) does it will be useful ?

vendor/github.com/mitchellh/go-ps/process.go:31:9: undefined: processes
vendor/github.com/mitchellh/go-ps/process.go:39:9: undefined: findProcess

Found in the FreeBSD port for this project: https://github.com/hashicorp/nomad

method refs: http://pythonhosted.org/psutil/#psutil.Process.children

A ─┐
   │
   ├─ B (child) ─┐
   │             └─ X (grandchild) ─┐
   │                                └─ Y (great grandchild)
   ├─ C (child)
   └─ D (child)

code

p.Children(false)
# return B, C, D
p.children(true)
# return B, X, Y, C, D

Can I make a pr?

I see in the file comment that it is possible to replace the cgo portion with go. What would that involve? I am interested as this causes an issue for us in nomad here hashicorp/nomad#1545

Thanks!

I wrote small Windows app that writes down list of processes, but it is shorter than what TaskManager shows. It seems that processes that are marked as "process name (32)" in TaskManager are not "visible" to go-ps.

Executable names are wonky. For example, /usr/bin/python3 /usr/share/unattended-upgrades/unattended-upgrade-shutdown --wait-for-signal is truncated to unattended-upgr.

unattended-upgr is not the real executable name. It's not even a filename. It's an incomplete part of the directory name supplied as a command line argument.

I am trying to make a "super alt f4" for linux, which kills the current active window when you press alt and f4 at the same time, however this package returns incomplete name for some processes such as league of legends running from wine.

I wish the path there could be configured, use case being that I have /proc of host mounted in a container. https://github.com/mitchellh/go-ps/blob/master/process_linux.go#L13

Code

package main

import (
    "fmt"
    "log"
     ps "github.com/mitchellh/go-ps"
)

func main() {

    if p, err := ps.Processes(); err != nil {
        log.Fatal(err)
    } else {
        for _, v := range p {
            fmt.Println(v.Executable())
        }
    }
}

Example Truncated process: NetworkBrowserAg

Is this a limitation of the system call sysctl or the implementation of the darwinProcesses() C function? It would be nice to have the full process name in order to instill confidence when selecting processes by name.

This tool will be largely helpful for systems /(administrators|engineers)/ who want to move to Go from the standard interpreted variety (which is great because packaging and deploying is easier). If the full process name is available, I wager that go-ps would be a bit more practical! What do you think?

Does it have Plan9 support ?

Hi,
I've wrote a simple archiving program in golang and i use a part of your code for getting process list and warn user when a predefined process is actually running.
Work like a charm, many thanks.
This utility will be available as MIT license like your own code.
Not published at this time (i need some times to use it and to decide it's safe to use without any damageable bugs) .
Have nice days and thanks again.